Python pyjavaproperties.Properties类代码示例

 def _testParsePropertiesInput(self, stream):
   properties = Properties()
   properties.load(stream)
   self.assertEquals(23, len(properties.items()))
   self.assertEquals('Value00', properties['Key00'])
   self.assertEquals('Value01', properties['Key01'])
   self.assertEquals('Value02', properties['Key02'])
   self.assertEquals('Value03', properties['Key03'])
   self.assertEquals('Value04', properties['Key04'])
   self.assertEquals('Value05a, Value05b, Value05c', properties['Key05'])
   self.assertEquals('Value06a, Value06b, Value06c', properties['Key06'])
   self.assertEquals('Value07b', properties['Key07'])
   self.assertEquals(
       'Value08a, Value08b, Value08c, Value08d, Value08e, Value08f',
       properties['Key08'])
   self.assertEquals(
       'Value09a, Value09b, Value09c, Value09d, Value09e, Value09f',
       properties['Key09'])
   self.assertEquals('Value10', properties['Key10'])
   self.assertEquals('', properties['Key11'])
   self.assertEquals('Value12a, Value12b, Value12c', properties['Key12'])
   self.assertEquals('Value13 With Spaces', properties['Key13'])
   self.assertEquals('Value14 With Spaces', properties['Key14'])
   self.assertEquals('Value15 With Spaces', properties['Key15'])
   self.assertEquals('Value16', properties['Key16 With Spaces'])
   self.assertEquals('Value17', properties['Key17 With Spaces'])
   self.assertEquals('Value18 # Not a comment.', properties['Key18'])
   self.assertEquals('Value19 ! Not a comment.', properties['Key19'])
   self.assertEquals('Value20', properties['Key20=WithEquals'])
   self.assertEquals('Value21', properties['Key21:WithColon'])
   self.assertEquals('Value22', properties['Key22'])

 def load_configuration(self):
     p = Properties()
     p.load(open(CONFIGURATION_PROPERTIES))
     self.producers_point = p['producers.point']
     # FIXME: auto acquire the name according to the machine's ip
     self.cluster_name = socket.gethostname().split('-')[0]
     self.ip = get_public_ip()

def getFilename():
    p = Properties();
    p.load(open('../../build.number.properties'));
    minor = p['build.minor'];
    major = p['build.major'];
    point = p['build.point'];
    filename = 'core_' + major + minor + point 
    return filename

def suffixFilename(filename, build):
    p = Properties();
    p.load(open('projects/mtg/build.number.properties'));
    minor = p['build.minor'];
    major = p['build.major'];
    point = p['build.point'];
    name, extension = os.path.splitext(filename)
    filename = name + '-' + major + minor + point + '-' + build + extension
    return filename

def get_dependency_projects():
    if os.path.exists(project_filename):
        with open(project_filename) as fsock:
            properties = Properties()
            properties.load(fsock)

            project  = re.compile(r'android.library.reference.\d+')
            return (value for key, value in properties.items() if project.match(key))
    else:
        return []

def load(filename=DEFAULT_CONFIG_FILENAME):
    p = Properties()
    if os.path.isfile(filename):
        p.load(open('stock.properties'))

    if not p['listed.pricePath'].strip():
        p['listed.pricePath'] = DEFAULT_LISTED_PRICE_PATH
    if not p['listed.instPath'].strip():
        p['listed.instPath'] = DEFAULT_LISTED_INST_PATH
    
    if not p['listed.lastDownload'].strip():
        p['listed.lastDownload'] = DEFAULT_START_DATE
    if p['listed.isDownload'].strip() != 'false':
        p['listed.isDownload'] = 'true'
    
    if not p['listed.lastUpdateDb'].strip():
        p['listed.lastUpdateDb'] = DEFAULT_START_DATE
    if p['listed.isUpdateDb'].strip() != 'false':
        p['listed.isUpdateDb'] = 'true'
    
    if not p['listed.lastUpdateIdx'].strip():
        p['listed.lastUpdateIdx'] = DEFAULT_START_DATE
    if p['listed.isUpdateIdx'].strip() != 'false':
        p['listed.isUpdateIdx'] = 'true'

    if not p['otc.pricePath'].strip():
        p['otc.pricePath'] = DEFAULT_OTC_PRICE_PATH
    if not p['otc.instPath'].strip():
        p['otc.instPath'] = DEFAULT_OTC_INST_PATH
        
    if not p['otc.lastDownload'].strip():
        p['otc.lastDownload'] = DEFAULT_START_DATE
    if p['otc.isDownload'].strip() != 'false':
        p['otc.isDownload'] = 'true'
    
    if not p['otc.lastUpdateDb'].strip():
        p['otc.lastUpdateDb'] = DEFAULT_START_DATE
    if p['otc.isUpdateDb'].strip() !='false':
        p['otc.isUpdateDb'] = 'true'
    
    if not p['otc.lastUpdateIdx'].strip():
        p['otc.lastUpdateIdx'] = DEFAULT_START_DATE
    if p['otc.isUpdateIdx'].strip() !='false':
        p['otc.isUpdateIdx'] = 'true'

    if not p['db.server'].strip():
        p['db.server'] = 'SERVER_NAME'
    if not p['db.username'].strip():
        p['db.username'] = 'USERNAME'
    if not p['db.password'].strip():
        p['db.password'] = 'PASSWORD'
    if not p['db.database'].strip():
        p['db.database'] = 'DATABASE_NAME'

    return p

def parse_property_file(filename):
    """
    parse java properties file
    :param filename: the path of the properties file
    :return: dictionary loaded from the file
    """
    if not os.path.isfile(filename):
        raise RuntimeError("No file found for parameter at {0}".format(filename))
    p = Properties()
    p.load(open(filename))
    return p

class Config(object):
    def __init__(self, filepath):
        self.filepath = filepath
        self.config = Properties()
        with open(filepath) as file:
            self.config.load(file)

    def get_property(self, key):
        return self.config[key]

    def has_property(self, key):
        return key in self.config.propertyNames()

 def __generate_workload_config(self, extraneous_config):
     # Read base workload properties into a dict if we haven't already
     if self.__base_workload_props is None:
         props = Properties()
         with open(self.workload_path) as wf:
             props.load(wf)
         self.__base_workload_props = props.getPropertyDict()
     if extraneous_config is None:
         extraneous_config = {}
     # Merge base workload properties with extraneous options
     workload_config = dict(self.__base_workload_props)
     workload_config.update(extraneous_config)
     # Merge and return the workload config dict
     return workload_config

    def __init__(self,*args):
        unittest.TestCase.__init__(self, *args)
        index = int(__file__.rfind("/"))
        basedir = __file__[0:index]

        p = Properties()
        p.load(open(basedir + '/gnip_account.properties'))
        p.load(open(basedir + '/test.properties'))
        self.gnip = Gnip(p['gnip.username'], p['gnip.password'], p['gnip.server'])
        self.testpublisher = p['gnip.test.publisher']
        self.testpublisherscope = p['gnip.test.publisher.scope']
        self.success = Result('Success')
        self.filterXml = None
        self.rules = None
        self.filterName = None
        self.filterFullData = None

    def parse(settingsdir=None):
        if settingsdir == None:
            settingsdir = JitsiProperties.path
        p = Properties()
        p.load(open(os.path.join(settingsdir, JitsiProperties.propertiesfile)))
        keydict = dict()
        for item in p.items():
            propkey = item[0]
            name = ""
            if re.match("net\.java\.sip\.communicator\.impl\.protocol\.jabber\.acc[0-9]+\.ACCOUNT_UID", propkey):
                name = JitsiProperties._parse_account_uid(item[1])
                if name in keydict:
                    key = keydict[name]
                else:
                    key = dict()
                    key["name"] = name
                    key["protocol"] = "prpl-jabber"
                    keydict[name] = key

                propkey_base = "net.java.sip.communicator.plugin.otr." + re.sub("[^a-zA-Z0-9_]", "_", item[1])
                private_key = p.getProperty(propkey_base + "_privateKey").strip()
                public_key = p.getProperty(propkey_base + "_publicKey").strip()
                numdict = util.ParsePkcs8(private_key)
                key["x"] = numdict["x"]
                numdict = util.ParseX509(public_key)
                for num in ("y", "g", "p", "q"):
                    key[num] = numdict[num]
                key["fingerprint"] = util.fingerprint((key["y"], key["g"], key["p"], key["q"]))
                verifiedkey = (
                    "net.java.sip.communicator.plugin.otr."
                    + re.sub("[^a-zA-Z0-9_]", "_", key["name"])
                    + "_publicKey_verified"
                )
                if p.getProperty(verifiedkey).strip() == "true":
                    key["verification"] = "verified"
            elif re.match("net\.java\.sip\.communicator\.plugin\.otr\..*_publicKey_verified", propkey):
                name, protocol = JitsiProperties._parse_account_from_propkey(settingsdir, propkey)
                if name != None:
                    if name not in keydict:
                        key = dict()
                        key["name"] = name
                        keydict[name] = key
                    if protocol and "protocol" not in keydict[name]:
                        keydict[name]["protocol"] = protocol
                    keydict[name]["verification"] = "verified"
            # if the protocol name is included in the property name, its a local account with private key
            elif re.match("net\.java\.sip\.communicator\.plugin\.otr\..*_publicKey", propkey) and not re.match(
                "net\.java\.sip\.communicator\.plugin\.otr\.(Jabber_|Google_Talk_)", propkey
            ):
                name, ignored = JitsiProperties._parse_account_from_propkey(settingsdir, propkey)
                if name not in keydict:
                    key = dict()
                    key["name"] = name
                    key["protocol"] = "prpl-jabber"
                    keydict[name] = key
                numdict = util.ParseX509(item[1])
                for num in ("y", "g", "p", "q"):
                    key[num] = numdict[num]
                key["fingerprint"] = util.fingerprint((key["y"], key["g"], key["p"], key["q"]))
        return keydict

    def parse(settingsdir=None):
        if settingsdir == None:
            settingsdir = JitsiProperties.path
        p = Properties()
        p.load(open(os.path.join(settingsdir, JitsiProperties.propertiesfile)))
        keydict = dict()
        for item in p.items():
            propkey = item[0]
            name = ''
            if re.match('net\.java\.sip\.communicator\.impl\.protocol\.jabber\.acc[0-9]+\.ACCOUNT_UID', propkey):
                name = JitsiProperties._parse_account_uid(item[1])
                if name in keydict:
                    key = keydict[name]
                else:
                    key = dict()
                    key['name'] = name
                    key['protocol'] = 'prpl-jabber'
                    keydict[name] = key

                propkey_base = ('net.java.sip.communicator.plugin.otr.'
                                + re.sub('[^a-zA-Z0-9_]', '_', item[1]))
                private_key = p.getProperty(propkey_base + '_privateKey').strip()
                public_key = p.getProperty(propkey_base + '_publicKey').strip()
                numdict = util.ParsePkcs8(private_key)
                key['x'] = numdict['x']
                numdict = util.ParseX509(public_key)
                for num in ('y', 'g', 'p', 'q'):
                    key[num] = numdict[num]
                key['fingerprint'] = util.fingerprint((key['y'], key['g'], key['p'], key['q']))
                verifiedkey = ('net.java.sip.communicator.plugin.otr.'
                               + re.sub('[^a-zA-Z0-9_]', '_', key['name'])
                               + '_publicKey_verified')
                if p.getProperty(verifiedkey).strip() == 'true':
                    key['verification'] = 'verified'
            elif (re.match('net\.java\.sip\.communicator\.plugin\.otr\..*_publicKey_verified', propkey)):
                name, protocol = JitsiProperties._parse_account_from_propkey(settingsdir, propkey)
                if name != None:
                    if name not in keydict:
                        key = dict()
                        key['name'] = name
                        keydict[name] = key
                    if protocol and 'protocol' not in keydict[name]:
                        keydict[name]['protocol'] = protocol
                    keydict[name]['verification'] = 'verified'
            # if the protocol name is included in the property name, its a local account with private key
            elif (re.match('net\.java\.sip\.communicator\.plugin\.otr\..*_publicKey', propkey) and not
                  re.match('net\.java\.sip\.communicator\.plugin\.otr\.(Jabber_|Google_Talk_)', propkey)):
                name, ignored = JitsiProperties._parse_account_from_propkey(settingsdir, propkey)
                if name not in keydict:
                    key = dict()
                    key['name'] = name
                    key['protocol'] = 'prpl-jabber'
                    keydict[name] = key
                numdict = util.ParseX509(item[1])
                for num in ('y', 'g', 'p', 'q'):
                    key[num] = numdict[num]
                key['fingerprint'] = util.fingerprint((key['y'], key['g'], key['p'], key['q']))
        return keydict

    def __init__(self, username, password, gnip_server=None, properties_file=None):
        """Initialize the class.

        @type username string
        @param username Your Gnip account username
        @type password string
        @param password Your Gnip account password
        @type gnip_server string
        @param gnip_server The Gnip server to connect to

        Initializes a Gnip class by setting up authentication
        information, used to log into the Gnip service.

        """

        p = Properties()
        if properties_file is not None:
            p.load(open(properties_file))
        else:
            index = int(__file__.rfind("/"))
            basedir = __file__[0:index]
            p.load(open(basedir + '/gnip.properties'))
        
        # Determine base Gnip URL
        if (gnip_server is None):
            self.base_url = p['gnip.server']
        else:
            self.base_url = gnip_server
        
        self.tunnel_over_post = bool(p['gnip.tunnel.over.post=false'])

        # Configure authentication
        self.client = httplib2.Http(timeout = int(p['gnip.http.timeout']))
        self.client.add_credentials(username, password)

        self.headers = {}
        self.headers['Accept'] = 'gzip, application/xml'
        self.headers['User-Agent'] = 'Gnip-Client-Python/2.1.0'
        self.headers['Content-Encoding'] = 'gzip'
        self.headers['Content-Type'] = 'application/xml'

    sys.stderr.write("Unspecified graph generation model (please use --help for help)\n")
    sys.exit(1)

if output_filename is None:
    # output_filename = os.path.join(script_dir, '../../../' + p['bench.datasets.directory'] + '/' + p['bench.graph.barabasi.file'])
    sys.stderr.write("The output file name is not specified (please use --help for help)\n")
    sys.exit(1)

model = string.lower(model)


#
# Load the properties
#

p = Properties()
p.load(open(os.path.join(script_dir, '../resources/com/tinkerpop/bench/bench.properties')))


#
# Model "Barabasi"
#

if model == "barabasi":
    
    if param_m is None:
        param_m = int(p['bench.graph.barabasi.degree'])
    if param_n is None:
        param_n = int(p['bench.graph.barabasi.vertices'])

    sys.stderr.write("Generating a Barabasi graph with n=%d, m=%d\n" % (param_n, param_m))

 def __init__(self, filepath):
     self.filepath = filepath
     self.config = Properties()
     with open(filepath) as file:
         self.config.load(file)