def propsTranslator(separator, inputfile, languages):
global CURR_LANGUAGE
for curr in languages:
CURR_LANGUAGE = curr
props = Properties()
with open(inputfile, 'rb') as f:
props.load(f, encoding='utf-8')
newProps = Properties()
for k, v in props.items():
print("translate: {} to language: {}".format(
v.data, CURR_LANGUAGE))
response = client.translate_text(
parent=GOOGLE_PARENT_PROJECT,
mime_type="text/plain",
target_language_code=CURR_LANGUAGE,
contents=[v.data])
trans = response.translations
print("result: {} \n".format(trans[0].translated_text))
newProps[k] = trans[0].translated_text
base = os.path.basename(inputfile)
filename = os.path.splitext(base)[0]
with open(filename + separator + CURR_LANGUAGE + '.properties',
'wb') as newF:
newProps.store(newF, encoding='utf-8')
def test_setmeta_bytes():
p = Properties()
p["a key"] = "the value", {b"metakey": b"metaval", b"__internal": b"foo"}
out = BytesIO()
p.store(out, strip_meta=False, timestamp=False)
out.seek(0)
assert out.read() == b"#: metakey=metaval\na\\ key=the value\n"
def test_setmeta_int():
p = Properties()
p["a key"] = "the value", {"metakey": 42}
out = BytesIO()
p.store(out, strip_meta=False, timestamp=False)
out.seek(0)
assert out.read() == b"#: metakey=42\na\\ key=the value\n"
def test_setmeta_bytes():
p = Properties()
p["a key"] = "the value", {b"metakey": b"metaval"}
out = StringIO()
p.store(out, strip_meta=False, timestamp=False)
out.seek(0)
assert out.read() == b"#: metakey=metaval\na\\ key=the value\n"
def test_setmeta_unicode():
p = Properties()
p["a key"] = "the value", {u"metakey": u"ünicode metävalue!"}
out = StringIO()
p.store(out, encoding="utf-8", strip_meta=False, timestamp=False)
out.seek(0)
assert out.read() == b"#: metakey=ünicode metävalue\\!\na\\ key=the value\n"
def test_setmeta_int():
p = Properties()
p["a key"] = "the value", {"metakey": 42}
out = StringIO()
p.store(out, strip_meta=False, timestamp=False)
out.seek(0)
assert out.read() == "#: metakey=42\na\\ key=the value\n"
def test_setmeta_unicode():
p = Properties()
p["a key"] = "the value", {u"metakey": u"ünicode metävalue!"}
out = StringIO()
p.store(out, encoding="utf-8", strip_meta=False, timestamp=False)
out.seek(0)
assert out.read(
) == b"#: metakey=ünicode metävalue\\!\na\\ key=the value\n"
def _generate_properties_file(self):
properties_file = os.path.join(CONFIG_PATH,
"cassandra-rackdc.properties")
cassandra_properties = Properties()
cassandra_properties["dc"] = "dc1"
cassandra_properties["rack"] = "rack1"
with open(properties_file, "wb") as f:
cassandra_properties.store(f, encoding="utf-8")
def test_load_write_file(datadir, tmpdir):
p = Properties()
with datadir["simple.utf8.prop"].open("rb") as fh:
p.load(fh, "utf-8")
with tmpdir.join("dump.prop").open("w+b") as out:
p.store(out, encoding="utf-8", timestamp=False)
out.seek(0)
assert out.read() == b"tästkey=This is the value\nanotherkey=Not mäny välues in this file\n"
def write_properties(configs, file, path=None):
if path is None:
path = '/opt'
pfile = Properties()
d_file = path + '/' + file + '.properties'
if configs is not None:
for k, v in configs.items():
pfile[k] = v
with open(d_file, 'wb') as f:
pfile.store(f, encoding='utf-8')
def test_load_write_file(datadir, tmpdir):
p = Properties()
with datadir["simple.utf8.prop"].open("rb") as fh:
p.load(fh, "utf-8")
with tmpdir.join("dump.prop").open("w+b") as out:
p.store(out, encoding="utf-8", timestamp=False)
out.seek(0)
assert out.read(
) == b"tästkey=This is the value\nanotherkey=Not mäny välues in this file\n"
def main(path):
properties = Properties()
with open(path, "rb") as f:
properties.load(f, "utf-8")
for key in properties.iterkeys():
if os.environ.get(key.replace('.', '_')):
properties[key] = os.environ[key.replace('.', '_')]
with open(path, "wb") as f:
f.truncate(0)
properties.store(f, encoding="utf-8")
def test_setmeta_unicode():
p = Properties()
p["a key"] = "the value", {
u"metakey": u"ünicode metävalue!",
u"__internal": u"foo"
}
out = BytesIO()
p.store(out, encoding="utf-8", strip_meta=False, timestamp=False)
out.seek(0)
text = u"#: metakey=ünicode metävalue\\!\na\\ key=the value\n".encode(
"utf-8")
assert out.read() == text
def _save_session_to(dir_path, session, filename, file_extension):
fig_dir_ = session['figures.directory']
if fig_dir_:
session['figures.directory'] = os.path.join(car_figures_dir, fig_dir_)
p = Properties()
for key in session:
p[key] = session[key]
session_file_path = os.path.join(dir_path, filename + file_extension)
with open(session_file_path, "w") as f:
p.store(f, encoding="utf-8")
msg = 'Session successfully stored as "' + filename + '"'
_log_info(msg)
return msg
def generateFromManualConfig(configPath):
with open(configPath, 'rb') as manCfg:
configList = json.load(manCfg)
dotEnv = DotEnv()
for config in configList:
tmplCfg = PropertyTemplate(config['file'] + '.template')
tmplCfg.updateExistingProperties(config['properties'])
dotEnv.updateProperties(config['properties'])
tmplCfg.generatePropertiesFile()
print('Random MariaDB root password:'******'MARIADB_ROOT_PASSWORD'])
p = Properties()
p.properties.update(dotEnv.envs)
with open(os.path.dirname(configPath) + os.path.sep + '.env', 'wb') as f:
p.store(f, encoding='utf-8')
def change_config(config_remote, config_file, fn):
from jproperties import Properties
read_props = Properties()
write_props = Properties()
if config_file is None:
return
with open(config_file, "r") as file:
read_props.load(file)
write_props = copy_exist(write_props, read_props)
write_props = fn(write_props, read_props, config_remote)
with open(config_file, "w") as wfile:
write_props.reset()
write_props.store(wfile)
def _save_session_to(dir_path, session, filename, file_extension):
fig_dir_ = session['figures.directory']
if fig_dir_:
session['figures.directory'] = os.path.join(car_figures_dir, fig_dir_)
p = Properties()
for key in session:
p[key] = session[key]
session_file_path = os.path.join(dir_path, filename + file_extension)
with open(session_file_path, "w") as f:
p.store(f, encoding="utf-8")
msg = 'Session successfully stored as "' + filename + '"'
_log_info(msg)
return msg
def test_surrogate_roundtrip_utf8():
p = Properties()
p["surrogate"] = u"Muuusic \U0001D160"
out = StringIO()
p.store(out, encoding="utf-8", timestamp=None)
out.seek(0)
dumped = out.read()
assert dumped == b"surrogate=Muuusic \xF0\x9D\x85\xA0\n"
p2 = Properties()
p2.load(dumped, "utf-8")
assert p2["surrogate"] == (u"Muuusic \U0001D160", {})
def test_surrogate_roundtrip(out_encoding):
p = Properties()
p["surrogate"] = u"Muuusic \U0001D160"
out = StringIO()
p.store(out, encoding=out_encoding, timestamp=None)
out.seek(0)
dumped = out.read()
assert dumped == b"surrogate=Muuusic \\ud834\\udd60\n"
p2 = Properties()
p2.load(dumped, out_encoding)
assert p2["surrogate"] == (u"Muuusic \U0001D160", {})
class PropertiesService:
def __init__(self, path, encoding="utf-8"):
self._properties = Properties()
self._path = path
self._encoding = encoding
with open(path, "rb") as f:
self._properties.load(f, encoding)
def get_property(self, key):
prop, meta = self._properties[key]
return prop
def save_property(self, key, value):
self._properties[key] = value
with open(self._path, "wb") as f:
self._properties.store(f, self._encoding)
def property_parser(schema, source, path, value):
with open(source, 'rb') as file:
content = Properties()
content.load(file, 'utf-8')
k = '.'.join(path)
try:
old_value, _ = content[k]
except Exception as e:
Log.get('property-parser').exception(f'Parsing property {k}', e)
old_value = None
if old_value != value:
content[k] = value
with open(source, 'wb') as file:
content.store(file, encoding='utf-8')
return {'value': {'new': value, 'old': old_value}}
else:
return {'note': NO_CHANGE_NEEDED}
def set_entry_dict(contents: Dict[str, str], file_path: str):
"""Sets the property file to the key-value pairs of the contents dictionary.
Args:
contents (Dict[str, str]): The dictionary whose contents will be the key value pairs of the properties file.
file_path (str): The path to the properties file to create.
"""
props = Properties()
for key, val in contents.items():
props[key] = val
parent_dir, file = os.path.split(file_path)
if not os.path.exists(parent_dir):
os.makedirs(parent_dir)
with open(file_path, "wb") as f:
props.store(f)
def getId(self, properties):
"""Function to get a new ID each time a file is created
Returns:
[integer] -- ID
"""
# Read last availaible id
p = Properties()
with open(properties, 'rb') as f:
p.load(f, 'utf-8')
id = str(int(p["video_id"].data))
# Increment the id in the file
p["video_id"] = str(int(p["video_id"].data) + 1)
with open(properties, 'wb') as f:
p.store(f, encoding="utf-8")
# Return availaible id
return id
def test_euro(out_encoding):
p = Properties()
# The euro symbol is not present in ASCII/ISO-8859-1,
# so it should be encoded as "\u20ac".
p["test"] = u"Euro: €"
out = StringIO()
p.store(out, encoding=out_encoding, timestamp=None)
out.seek(0)
assert out.read() == b"test=Euro\\: \\u20ac\n"
# Read it back again:
out.seek(0)
p2 = Properties()
p2.load(out)
assert p2.properties == {u"test": u"Euro: €"}
def test_euro(out_encoding):
p = Properties()
# The euro symbol is not present in ASCII/ISO-8859-1,
# so it should be encoded as "\u20ac".
p["test"] = u"Euro: €"
out = StringIO()
p.store(out, encoding=out_encoding, timestamp=None)
out.seek(0)
assert out.read() == b"test=Euro\\: \\u20ac\n"
# Read it back again:
out.seek(0)
p2 = Properties()
p2.load(out)
assert p2.properties == {u"test": u"Euro: €"}
def load_world_and_config():
# Get current properties
props = Properties()
with open(properties_path, "rb") as f:
props.load(f, "utf-8")
# Select world
world_list = [x.name for x in Path(worlds_path).iterdir() if x.is_dir()]
level_name = inquirer.prompt([
inquirer.List("level-name",
message="Select a world",
choices=world_list,
default=props["level-name"].data),
])["level-name"]
# Load world's configuration
world_props_path = Path(worlds_path, level_name + ".properties")
world_props = Properties()
if world_props_path.is_file():
with open(world_props_path, "rb") as f:
world_props.load(f, "utf-8")
else:
print("No configuration found for this world\n")
world_props["level-name"] = level_name
props.update(world_props)
print("Writing following config to server.properties:")
pprint.pprint(world_props.properties)
print()
with open(properties_path, "wb") as f:
props.store(f, encoding="utf-8")
# Prompt for restart/start
action = inquirer.prompt([
inquirer.Confirm(
"action",
message=f"{'Restart' if server_is_running() else 'Start'} server?",
default=True),
])["action"]
if action:
restart_server() if server_is_running() else start_server()
def property_parser(schema, source, path, value):
with open(source, 'rb') as file:
content = Properties()
content.load(file, 'utf-8')
k = '.'.join(path)
try:
old_value, _ = content[k]
except Exception as e:
Log.get('property-parser').exception(e)
old_value = None
if old_value != value:
content[k] = value
with open(source, 'wb') as file:
content.store(file, encoding='utf-8')
return dict(schema=schema,
source=source,
path=path,
value=dict(new=value, old=old_value))
else:
return dict(schema=schema,
source=source,
path=path,
value=value,
note=NO_CHANGE_NEEDED)
def processJavaParameters(params, fh):
"""
Take parameters, get all of their keys and values, and write them to the
output file handle as Java property values.
Args:
params (Iterator): generator for the parameters.
fh (file-like): An open, writeable file handle to output the Java properties values.
"""
props = Properties()
for param, basePath in params:
paramPath = param['Name'][len(basePath):]
m = JAVA_PARAMETER_NAME_RE.search(paramPath)
if not m:
logger.warning(
'%(Name)s: skipping parameter because of invalid Java property name',
param)
continue
name = m.group('name')
value = param['Value']
if param['Type'] == 'SecureString':
logger.debug('%(path)s: %(name)s = ********', {
'path': param['Name'],
'name': name
})
else:
logger.debug('%(path)s: %(name)s = %(value)s', {
'path': param['Name'],
'name': name,
'value': value
})
props[name.replace('/', '.')] = value
props.store(fh, encoding="utf-8")
type=str,
help='Kafka Server Template')
parser.add_argument('--server_count',
'-n',
default=5,
type=int,
help='Kafka Number of Server')
parser.add_argument('--logs_dir',
'-cd',
default='/tmp/kafka-logs',
help='hbase logs dir')
args = parser.parse_args()
p = Properties(process_escapes_in_values=False)
p.load(open(args.config_template, 'rb'), 'utf-8')
for i in range(0, args.server_count):
# p['broker.id'] = str(int(p['broker.id'].data) + 1)
p['broker.id'] = str(i)
p['port'] = str(9092 + i)
p['log.dirs'] = '{}/{}'.format('/tmp/kafka-logs', i)
# p['zookeeper.connect'] = 'localhost:2181'
# p['advertised.host.name'] = 'localhost'
# p['listeners'] = 'PLAINTEXT://localhost:{}'.format(9092 + i)
# p['delete.topic.enable'] = 'true'
with open('./configs/server-{}.properties'.format(i), 'wb') as f:
p.store(f, strip_meta=False)
f.close()
test = os.environ['bamboo_planRepository_repositoryUrl']
print("API BUILD NUMBER IS ===========> " + build)
print("API REPO NAME IS ===========> " + test)
# maven clean package to create war file
subprocess.call(["mvn", "clean", "package"], shell=True)
#upload war file into artifactory location
url = os.environ[
'bamboo_artifactory_url'] + "com/services/{0}/{1}-0.0.1-SNAPSHOT.war".format(
build, planName)
file_name = "target/{0}-0.0.1-SNAPSHOT.war".format(planName)
auth = (os.environ['bamboo_artifactory_username'],
os.environ['bamboo_artifactory_password'])
with open(file_name, 'rb') as fobj:
res = requests.put(url, auth=auth, data=fobj)
print(res.text)
print(res.status_code)
#Update build number and repo name in the properties file.
p = Properties()
p["BUILD_NUMMBER"] = build
p["REPO_NAME"] = planName
with open("bambo-test.properties", "wb") as f:
p.store(f, encoding="utf-8")
print("==================API Build Ends ====================")
#curl -u admin:Welcome@123 -X PUT -F "data=@target/employeservice-0.0.1-SNAPSHOT.war" http://localhost:8082/artifactory/DEMO/com/services/build/employeservice-0.0.1-SNAPSHOT.war
def writeproperties(path, **kwargs):
p = Properties()
for k, v in kwargs.items():
p[k] = v
with path.open('wb') as f:
p.store(f)
def save_properties(self, p: Properties):
with open(self.get_properties_path(), 'wb') as f:
p.store(f, encoding='utf-8')
return
from ec2_metadata import ec2_metadata
client = boto3.client('secretsmanager', region_name=ec2_metadata.region)
if (len(sys.argv) == 1):
print("No secrets to be mounted, exiting")
sys.exit(0)
secret_names = sys.argv[1].split(",")
out_directory = sys.argv[2]
file_type = sys.argv[3]
values = {
secret["Name"].replace('/', '.'): secret["SecretString"]
for secret in map(lambda name: client.get_secret_value(SecretId=name),
secret_names)
}
file_name = "%s/secrets.%s" % (out_directory, file_type)
if file_type == "yaml":
yaml.dump(unflatten(values), open(file_name, 'w'), explicit_start=True)
elif file_type == "json":
json.dump(unflatten(values), open(file_name, 'w'))
elif file_type == "toml":
toml.dump(unflatten(values), open(file_name, 'w'))
else:
properties = Properties()
properties.properties = values
with open(file_name, "wb") as out_file:
properties.store(out_file, strict=True)
def generatePropertiesFile(self):
p = Properties()
p.properties.update(self.existingProps)
with open(self.destPath, 'wb') as f:
p.store(f, encoding='utf-8')
