class JsonToConfig(object):
def __init__(self):
self.cfw = RawConfigParser()
self.resources = {}
self.init_resources()
def init_resources(self):
if os.path.exists(resource_path):
f = open(resource_path, 'r')
data = f.read()
f.close()
if len(data) > 0:
self.resources = json.loads(data)
def set_cf(self, service, option):
item = self.resources[service][option]
self.cfw.set(service, option, item)
def main(self):
# print(self.resources)
for service in self.resources:
keys = self.resources[service].keys()
if len(keys) != 0:
self.cfw.add_section(service)
for option in keys:
self.set_cf(service, option)
f = open(config_file_path, 'w')
self.cfw.write(f)
class ReadConfig:
"""读取配置文件"""
def __init__(self):
self.config = RawConfigParser()
self.config.read(contants.global_conf_file,
encoding='utf-8') #先读取global.conf文件
switch = self.config.getboolean(
'switch',
'on') #global.conf文件中的switch如果是true就去读取online.conf，相反就去读取test.conf
if switch:
self.config.read(contants.online_conf_file, encoding='utf-8')
else:
self.config.read(contants.test_conf_file, encoding='utf-8')
def get_str(self, section, option):
return self.config.get(section, option)
def get_int(self, section, option):
return self.config.getint(section, option)
def get_float(self, section, option):
return self.config.getfloat(section, option)
def get_bool(self, section, option):
return self.config.getboolean(section, option)
def write(self, section, option, value):
self.config.set(section, option, value)
with open(contants.test_conf_file, 'w') as f:
self.config.write(f)
def set(self, section, option, new_value):
with self.lock:
if self.callback and self.has_section(section) and self.has_option(section, option):
old_value = self.get(section, option)
if not self.callback(section, option, new_value, old_value):
raise OperationNotPossibleAtRuntimeException
RawConfigParser.set(self, section, option, new_value)
def write(self, config_data, filepath=None):
"""
Create a dotfile from keyword arguments.
:param config_data:
Dict of config settings
:param filepath:
(Optional) Path to write
"""
if filepath is None:
filepath = self.filepath
config = RawConfigParser()
section = constants.SECTION_NAME
config.add_section(section)
# Set the config settings
for key, val in six.iteritems(config_data):
config.set(section, key, val)
with open(filepath, 'w') as dotfile:
config.write(dotfile)
self.enforce_perms()
log.debug('wrote %s' % filepath)
def test_parse_config(self):
fd, filename = tempfile.mkstemp()
fp = os.fdopen(fd, 'w')
try:
cp = RawConfigParser()
cp.add_section('sec')
cp.set('sec', 'foo', 'foo')
cp.set('sec', 'bar', '-1')
cp.set('sec', 'baz', '-0.1')
cp.set('sec', 'hum', 'yes')
cp.set('sec', 'dum', 'no')
cp.write(fp)
fp.close()
self.define_opt('sec', 'foo')
self.define_opt('sec', 'bar', type=int)
self.define_opt('sec', 'baz', type=float)
self.define_opt('sec', 'hum', type=bool)
self.define_opt('sec', 'dum', type=bool)
self.parse_config(filename)
self.verify_all_options()
self.assertEqual(self.options.sec.foo, 'foo')
self.assertEqual(self.options.sec.bar, -1)
self.assertAlmostEqual(self.options.sec.baz, -0.1)
self.assertEqual(self.options.sec.hum, True)
self.assertEqual(self.options.sec.dum, False)
finally:
os.unlink(filename)
def _read_from_sections(user, collection_url, permission):
regex = ConfigParser({'login': user, 'path': collection_url})
for rights in (INITIAL_RIGHTS, settings.DJRADICALE_RIGHTS):
for section, values in rights.items():
if not regex.has_section(section):
regex.add_section(section)
for key, value in values.items():
regex.set(
section, key,
value % {
'login': re.escape(user),
'path': re.escape(collection_url),
})
log.LOGGER.debug("Rights type '%s'" % __name__)
for section in regex.sections():
re_user = regex.get(section, 'user')
re_collection = regex.get(section, 'collection')
log.LOGGER.debug(
"Test if '%s:%s' matches against '%s:%s' from section '%s'" % (
user, collection_url, re_user, re_collection, section))
user_match = re.match(re_user, user)
if user_match:
re_collection = re_collection.format(*user_match.groups())
if re.match(re_collection, collection_url):
log.LOGGER.debug("Section '%s' matches" % section)
if permission in regex.get(section, 'permission'):
return True
else:
log.LOGGER.debug("Section '%s' does not match" % section)
return False
def write(self, fp):
parser = RawConfigParser()
for section in self:
parser.add_section(section)
for key, value in self.items(section):
parser.set(section, key, value)
parser.write(fp)
def init_admin_repository(
git_dir,
pubkey,
user,
):
repository.init(path=git_dir,
template=resource_filename('gitosis.templates', 'admin'))
repository.init(path=git_dir, )
# can't rely on setuptools and all kinds of distro packaging to
# have kept our templates executable, it seems
os.chmod(os.path.join(git_dir, 'hooks', 'post-update'), 0o755)
if not repository.has_initial_commit(git_dir):
log.info('Making initial commit...')
# ConfigParser does not guarantee order, so jump through hoops
# to make sure [gitosis] is first
cfg_file = StringIO()
print('[gitosis]', file=cfg_file)
#print('', end="", file=cfg_file)
#print >>cfg_file, '[gitosis]'
#print >>cfg_file
cfg = RawConfigParser()
cfg.add_section('group gitosis-admin')
cfg.set('group gitosis-admin', 'members', user)
cfg.set('group gitosis-admin', 'writable', 'gitosis-admin')
cfg.write(cfg_file)
initial_commit(
git_dir=git_dir,
cfg=cfg_file.getvalue(),
pubkey=pubkey,
user=user,
)
def test_no_notListed():
cfg = RawConfigParser()
cfg.add_section('group hackers')
cfg.set('group hackers', 'members', 'wsmith')
gen = group.getMembership(config=cfg, user='******')
eq(gen.next(), 'all')
assert_raises(StopIteration, gen.next)
def test_parse_config(self):
fd, filename = tempfile.mkstemp()
fp = os.fdopen(fd, 'w')
try:
cp = RawConfigParser()
cp.add_section('sec')
cp.set('sec', 'foo', 'foo')
cp.set('sec', 'bar', '-1')
cp.set('sec', 'baz', '-0.1')
cp.set('sec', 'hum', 'yes')
cp.set('sec', 'dum', 'no')
cp.write(fp)
fp.close()
self.define_opt('sec', 'foo')
self.define_opt('sec', 'bar', type=int)
self.define_opt('sec', 'baz', type=float)
self.define_opt('sec', 'hum', type=bool)
self.define_opt('sec', 'dum', type=bool)
self.parse_config(filename)
self.verify_all_options()
self.assertEqual(self.options.sec.foo, 'foo')
self.assertEqual(self.options.sec.bar, -1)
self.assertAlmostEqual(self.options.sec.baz, -0.1)
self.assertEqual(self.options.sec.hum, True)
self.assertEqual(self.options.sec.dum, False)
finally:
os.unlink(filename)
def _set_repository_id(self, path, id):
config = RawConfigParser()
config.read(os.path.join(path, "config"))
config.set("repository", "id", hexlify(id).decode("ascii"))
with open(os.path.join(path, "config"), "w") as fd:
config.write(fd)
return Repository(self.repository_path).id
def set(self, option, value):
"""Set the value of an option.
If the new `value` has been set, the configuration file will be
immediately updated.
Throws a ``ConfigError`` if `value` couldn't be converted to
``LazyConfigOption.cls`` or ``LazyConfigOption.validate`` fails."""
section, option_ = self._get_section_option(option)
try:
val = self._cfg[section][option_].cls(value)
if self._cfg[section][option_].validate:
val = self._cfg[section][option_].validate(val)
except (ValueError, ConfigValueError) as err:
raise ConfigError(str(err), CONF_ERROR)
# Do not write default values also skip identical values
if not self._cfg[section][option_].default is None:
old_val = self.dget(option)
else:
old_val = self.pget(option)
if val == old_val:
return
if not RawConfigParser.has_section(self, section):
self.add_section(section)
RawConfigParser.set(self, section, option_, val)
self._save_changes()
def store_waitwait_downloaddir(waitwait_downloaddir):
"""
Stores the default location of the `NPR Fresh Air`_ episodes into the configuration file, ``~/.config/nprstuff/nprstuff.com``, into the ``NPR_DATA`` section and ``waitwait_downloaddir`` key.
:param str waitwait_downloaddir: the default directory to download `NPR Fresh Air`_ episodes.
.. seealso:: :py:meth:`get_waitwait_downloaddir <nprstuff.core.npr_utils.get_waitwait_downloaddir>`.
"""
assert (os.path.isdir(os.path.abspath(waitwait_downloaddir)))
resource = 'nprstuff'
filename = '%s.conf' % resource
baseConfDir = os.path.abspath(os.path.expanduser('~/.config/%s' %
resource))
absPath = os.path.join(baseConfDir, filename)
if os.path.isdir(absPath):
shutil.rmtree(absPath)
if not os.path.isfile(absPath):
cparser = RawConfigParser()
else:
cparser = ConfigParser()
cparser.read(absPath)
if 'NPR_DATA' not in cparser.sections():
cparser.add_section('NPR_DATA')
cparser.set('NPR_DATA', 'waitwait_downloaddir',
os.path.abspath(waitwait_downloaddir))
with open(absPath, 'w') as openfile:
cparser.write(openfile)
os.chmod(absPath, 0o600)
def run_setup(self, config_file):
print(textwrap.dedent("""\
Hi, it looks like it's the first time you're using pwm on this machine. Let's take a little
moment to set things up before we begin."""))
db_uri = input('Which database do you want to use (default: local sqlite at ~/.pwm/db.sqlite) ').strip() or 'local'
rc_dir = os.path.dirname(config_file)
if db_uri == 'local':
# normalize windows-style paths for sqlalchemy:
rc_dir = rc_dir.replace('\\', '/')
# Create the local database
db_uri = 'sqlite:///%s/db.sqlite' % rc_dir
if not '://' in db_uri:
# Not a sqlalchemy-compatible connection string or https URI, assume it's a local path and make a sqlite
# uri out of it
db_uri = 'sqlite:///%s' % db_uri
if not (db_uri.startswith('https:') or db_uri.startswith('http:')):
# It's a local db, make sure our tables exist
db = sa.create_engine(db_uri)
Base.metadata.create_all(db)
config_parser = RawConfigParser()
config_parser.add_section('pwm')
config_parser.set('pwm', 'database', db_uri)
with open(config_file, 'w') as config_file_fh:
config_parser.write(config_file_fh)
def add_section(filename: str, section: str, data: {}):
config = RawConfigParser()
config.add_section(section)
for key, value in data.items():
config.set(section, key, value)
with open(filename, 'a+') as cfgfile:
config.write(cfgfile)
def collect_sculpture(actors, root_now):
for each_actor in actors:
path_exist_actor = '演员头像' + sep + each_actor[
0] + sep + each_actor # 事先准备好的演员头像路径
if exists(path_exist_actor + '.jpg'):
pic_type = '.jpg'
elif exists(path_exist_actor + '.png'):
pic_type = '.png'
else:
config_actor = RawConfigParser()
config_actor.read('【缺失的演员头像统计For Kodi】.ini', encoding='utf-8-sig')
try:
each_actor_times = config_actor.get('缺失的演员头像', each_actor)
config_actor.set("缺失的演员头像", each_actor,
str(int(each_actor_times) + 1))
except:
config_actor.set("缺失的演员头像", each_actor, '1')
config_actor.write(
open('【缺失的演员头像统计For Kodi】.ini', "w", encoding='utf-8-sig'))
continue
# 已经收录了这个演员头像
root_dest_actor = root_now + sep + '.actors' + sep # 头像的目标文件夹
if not exists(root_dest_actor):
makedirs(root_dest_actor)
# 复制一份到“.actors”
copyfile(path_exist_actor + pic_type,
root_dest_actor + each_actor + pic_type)
print(' >演员头像收集完成：', each_actor)
def collect_sculpture(self, list_actors, dir_current):
if handler.bool_sculpture and jav_file.episode == 1:
if jav_model.Actors[0] == '有码演员':
print(' >未知演员，无法收集头像')
else:
for each_actor in list_actors:
path_exist_actor = f'演员头像{sep}{each_actor[0]}{sep}{each_actor}' # 事先准备好的演员头像路径
if os.path.exists(f'{path_exist_actor}.jpg'):
pic_type = '.jpg'
elif os.path.exists(f'{path_exist_actor}.png'):
pic_type = '.png'
else:
config_actor = RawConfigParser()
config_actor.read('【缺失的演员头像统计For Kodi】.ini',
encoding='utf-8-sig')
try:
each_actor_times = config_actor.get(
'缺失的演员头像', each_actor)
config_actor.set("缺失的演员头像", each_actor,
str(int(each_actor_times) + 1))
except:
config_actor.set("缺失的演员头像", each_actor, '1')
config_actor.write(
open('【缺失的演员头像统计For Kodi】.ini',
"w",
encoding='utf-8-sig'))
continue
# 已经收录了这个演员头像
dir_dest_actor = f'{dir_current}{sep}.actors{sep}' # 头像的目标文件夹
if not os.path.exists(dir_dest_actor):
os.makedirs(dir_dest_actor)
# 复制一份到“.actors”
copyfile(f'{path_exist_actor}{pic_type}',
f'{dir_dest_actor}{each_actor}{pic_type}')
print(' >演员头像收集完成：', each_actor)
class Options:
def __init__(self, name, defaults):
load_paths = list(reversed([os.path.join(directory, '%s.cfg' % name)
for directory
in load_config_paths(name)]))
self.save_path = os.path.join(save_config_path(name), '%s.cfg' % name)
self.config = RawConfigParser(defaults)
self.paths = self.config.read(load_paths)
self.section = name if self.config.has_section(name) else 'DEFAULT'
def get(self, option):
try:
return self.config.get(self.section, option)
except NoOptionError:
return None
def set(self, option, value):
if value is not None:
self.config.set(self.section, option, value)
else:
self.config.remove_option(self.section, option)
defaults = self.config._defaults
self.config._defaults = None
with open(self.save_path, 'w') as save_file:
self.config.write(save_file)
self.config._defaults = defaults
def _set_repository_id(self, path, id):
config = RawConfigParser()
config.read(os.path.join(path, 'config'))
config.set('repository', 'id', hexlify(id).decode('ascii'))
with open(os.path.join(path, 'config'), 'w') as fd:
config.write(fd)
return Repository(self.repository_path).id
def create_storage_account(storagename,
resource_group_name,
location_storage='westeurope',
sku='Standard_LRS',
storage_kind='StorageV2',
config_name='default',
saveconfig=True):
file_path = os.path.join(os.getcwd(),
'batch_files\create_storage_account.bat')
os.system("C:\Windows\System32\cmd.exe /c " + file_path + ' ' +
storagename + ' ' + resource_group_name + ' ' +
location_storage + ' ' + sku + ' ' + storage_kind)
if saveconfig == True:
if not os.path.exists("config"):
os.mkdir("config")
print(
"Saving Configuration to config/blob.ini \n Please Keep This File Secure."
)
config = RawConfigParser()
config.read('config/blob.ini')
config.add_section(config_name)
config.set(config_name, 'storagename', storagename)
config.set(config_name, 'resource_group_name', resource_group_name)
config.set(config_name, 'location_storage', location_storage)
config.set(config_name, 'sku', sku)
config.set(config_name, 'storage_kind', storage_kind)
with open('config/blob.ini', 'w') as f:
config.write(f)
def set_and_save(self, option, value, section=DEFSECTION):
"""
set the value in the configuration then save it
to the file
"""
# Special case for a 'toggle' value. We take the current value
# and set the opposite. Warning if the no current value exists
# or it is not a bool.
if value == "toggle":
current = self.get(option, "", section)
if isinstance(current, bool):
value = str(not current)
else:
if current.lower() == "false":
value = "true"
elif current.lower() == "true":
value = "false"
else:
return (_('Could not toggle option: %s.'
' Current value is %s.') %
(option, current or _("empty")),
'Warning')
if self.has_section(section):
RawConfigParser.set(self, section, option, value)
else:
self.add_section(section)
RawConfigParser.set(self, section, option, value)
if not self.write_in_file(section, option, value):
return (_('Unable to write in the config file'), 'Error')
return ("%s=%s" % (option, value), 'Info')
def update_config(path, section, values):
"""
Function to update config file.
:param path: Path to config file
:type: str
:param section: Config section
:type: str
:param values: Dict with new values
:type: dict
:return: True or False
:rtype: bool
"""
cfg = RawConfigParser()
if os.path.exists(path):
cfg.read(path)
for opt, val in values.items():
cfg.set(section, opt, val)
try:
with open(path, 'w') as config_file:
cfg.write(config_file)
return True
except PermissionError:
return False
def run_setup(self, config_file):
print(
textwrap.dedent("""\
Hi, it looks like it's the first time you're using pwm on this machine. Let's take a little
moment to set things up before we begin."""))
db_uri = input(
'Which database do you want to use (default: local sqlite at ~/.pwm/db.sqlite) '
).strip() or 'local'
rc_dir = os.path.dirname(config_file)
if db_uri == 'local':
# normalize windows-style paths for sqlalchemy:
rc_dir = rc_dir.replace('\\', '/')
# Create the local database
db_uri = 'sqlite:///%s/db.sqlite' % rc_dir
if not '://' in db_uri:
# Not a sqlalchemy-compatible connection string or https URI, assume it's a local path and make a sqlite
# uri out of it
db_uri = 'sqlite:///%s' % db_uri
if not (db_uri.startswith('https:') or db_uri.startswith('http:')):
# It's a local db, make sure our tables exist
db = sa.create_engine(db_uri)
Base.metadata.create_all(db)
config_parser = RawConfigParser()
config_parser.add_section('pwm')
config_parser.set('pwm', 'database', db_uri)
with open(config_file, 'w') as config_file_fh:
config_parser.write(config_file_fh)
def _set_repository_id(self, path, id):
config = RawConfigParser()
config.read(os.path.join(path, 'config'))
config.set('repository', 'id', hexlify(id).decode('ascii'))
with open(os.path.join(path, 'config'), 'w') as fd:
config.write(fd)
return Repository(self.repository_path).id
def _init_config_parser():
"""
Creates the RawConfigParser object, adds the fields and fills with default/empty values
:return:
"""
global _conf_parser
# Create a new config parser
_conf_parser = RawConfigParser()
# Put all options under a Settings Header
_conf_parser.add_section("Settings")
# Create defaults tuple
SettingsDefault = namedtuple('SettingsDefault',
['setting', 'default_value'])
default_settings = [
SettingsDefault._make(["client_id", ""]),
SettingsDefault._make(["client_secret", ""]),
SettingsDefault._make(["username", ""]),
SettingsDefault._make(["password", ""]),
SettingsDefault._make(["base_url", ""]),
SettingsDefault._make(["parser", "directory"])
]
# add defaults to config parser
for config in default_settings:
_conf_parser.set("Settings", config.setting, config.default_value)
def _save_config_file(self, config):
"""Write config to disk.
"""
# Generate a sanitized version of our running configuration
sane_config = RawConfigParser()
for section_name, section in config.items():
sane_config.add_section(section_name)
for option_name, value in section.items():
if self.config_source[section_name][
option_name] == 'config_file' and value is not None:
sane_config.set(section_name, option_name, str(value))
if not self.config_dir.exists():
self.config_dir.mkdir(parents=True, exist_ok=True)
# Write the config file atomically.
self.acquire_lock()
with NamedTemporaryFile(mode='w',
dir=str(self.config_dir),
delete=False) as tmpfile:
sane_config.write(tmpfile)
if os.path.getsize(tmpfile.name) > 0:
os.replace(tmpfile.name, str(self.config_file))
else:
self.log.warning(
'Config file saving failed, not replacing %s with %s.',
str(self.config_file), tmpfile.name)
self.release_lock()
def _update_release_version_for_sanic(current_version, new_version,
config_file):
config_parser = RawConfigParser()
with open(config_file) as cfg:
config_parser.read_file(cfg)
config_parser.set("version", "current_version", new_version)
version_file = config_parser.get("version", "file")
current_version_line = config_parser.get(
"version",
"current_version_pattern").format(current_version=current_version)
new_version_line = config_parser.get(
"version", "new_version_pattern").format(new_version=new_version)
with open(version_file) as init_file:
data = init_file.read()
new_data = data.replace(current_version_line, new_version_line)
with open(version_file, "w") as init_file:
init_file.write(new_data)
with open(config_file, "w") as config:
config_parser.write(config)
command = GIT_COMMANDS.get("commit_version_change")
command[0] = command[0].format(new_version=new_version,
current_version=current_version)
_, err, ret = _run_shell_command(command)
if int(ret) != 0:
print("Failed to Commit Version upgrade changes to Sanic: {}".format(
err.decode("utf-8")))
exit(1)
def test_clean_no_extension(self):
repo = self.make_clone("clone to clean", "default")
rc_path = os.path.join(repo.target_dir, ".hg", "hgrc")
# make sure that 'purge' extension is NOT activated
# we expect it to be installed on the system this test runs
# note that that's the case with Debian and Red Hat families of
# distributions
parser = RawConfigParser()
parser.read(rc_path)
parser.add_section("extensions")
parser.set("extensions", "hgext.purge", "!")
with open(rc_path, "w") as rc:
parser.write(rc)
dirty_dir = os.path.join(repo.target_dir, "dirty")
os.mkdir(dirty_dir)
dirty_files = (
os.path.join(repo.target_dir, "untracked.pyc"),
os.path.join(dirty_dir, "untracked2.pyo"),
)
for path in dirty_files:
with open(path, "w") as f:
f.write("content")
repo.clean()
for path in dirty_files:
self.assertFalse(
os.path.exists(path),
"Untracked file %r should have been removed" % path,
)
self.assertFalse(os.path.exists(dirty_dir),
"Untracked dir should have been removed")
def save_jwt_token(token, expiration=None, path=None):
"""
Saves JWT token in the config file.
"""
# Default to ~/.htrc
if path is None:
path = DEFAULT_PATH
# Default to expiration of now - force a new token on next request
if expiration is None:
expiration = time.time()
# Open and modify existing config file, if it exists.
config = ConfigParser(allow_no_value=True)
if os.path.exists(path):
config.read(path)
if not config.has_section('jwt'):
config.add_section('jwt')
# set token and expiration
config.set('jwt', 'token', token)
config.set('jwt', 'expiration', expiration)
with open(path, 'w') as credential_file:
config.write(credential_file)
return token
def _init_config_parser():
"""
Creates the RawConfigParser object, adds the fields and fills with default/empty values
:return:
"""
global _conf_parser
# Create a new config parser
_conf_parser = RawConfigParser()
# Put all options under a Settings Header
_conf_parser.add_section("Settings")
# Create defaults tuple
SettingsDefault = namedtuple('SettingsDefault',
['setting', 'default_value'])
default_settings = [
SettingsDefault._make(["client_id", ""]),
SettingsDefault._make(["client_secret", ""]),
SettingsDefault._make(["username", ""]),
SettingsDefault._make(["password", ""]),
SettingsDefault._make(["base_url", ""]),
SettingsDefault._make(["parser", "directory"]),
SettingsDefault._make(["readonly", False]),
SettingsDefault._make(["delay", 0]),
SettingsDefault._make(
["timeout", 10]), # default timeout scale is 10 seconds per mb
SettingsDefault._make(["minimum_file_size", 0])
] # default minimum file size in kb
# add defaults to config parser
for config in default_settings:
_conf_parser.set("Settings", config.setting, config.default_value)
def authorized(self, user, path, permission):
# collection_url = collection.url.rstrip('/') or '/'
# if collection_url in ('.well-known/carddav', '.well-known/caldav'):
# return permission == 'r'
# return _read_from_sections(user or '', collection_url, permission)
regex = ConfigParser({'login': user, 'path': path})
for rights in (INITIAL_RIGHTS, settings.DJRADICALE_RIGHTS):
for section, values in rights.items():
if not regex.has_section(section):
regex.add_section(section)
for key, value in values.items():
regex.set(
section, key, value % {
'login': re.escape(user),
'path': re.escape(path),
})
self.logger.debug("Rights type '%s'" % __name__)
for section in regex.sections():
re_user = regex.get(section, 'user')
re_collection = regex.get(section, 'collection')
log.LOGGER.debug(
"Test if '%s:%s' matches against '%s:%s' from section '%s'" %
(user, path, re_user, re_collection, section))
user_match = re.match(re_user, user)
if user_match:
re_collection = re_collection.format(*user_match.groups())
if re.match(re_collection, path):
self.logger.debug("Section '%s' matches" % section)
if permission in regex.get(section, 'permission'):
return True
else:
self.logger.debug("Section '%s' does not match" % section)
return False
class ConfigHandler:
def __init__(self, file_name):
self.conf = RawConfigParser()
self.file_name = os.path.join(conf_loc, file_name)
self.conf.read(self.file_name, encoding='utf-8')
def get_sections(self):
"""获取所有的sections"""
return self.conf.sections()
def get_options(self, section):
"""获取section下所有的option"""
return self.conf.options(section)
def read(self, section, option):
"""读取section，下option的值"""
return self.conf.get(section, option)
def write(self, section, option, value):
"""1、判断该片段是否存在，不存在新增加一个节点
2、该节点存在的话，如果键存在，更新值
3、键不存在，新增一个键，并为其赋值
"""
if not self.conf.has_section(section):
self.conf.add_section(section)
self.conf.set(section, option, value)
with open(self.file_name, 'w', encoding='utf-8') as f:
self.conf.write(f)
def return_data(self, section, option):
"""将查询到的数据范围为原类型"""
result = self.read(section, option)
return eval(result)
class Config(object):
def __init__(self, file='config.ini'):
super().__init__()
self.file = file
self.config = RawConfigParser()
self.config.read(self.file, encoding='utf-8') # 读取文件
def getConfig(self, section, option):
'''
读取config.ini配置文件
'''
try:
return self.config.get(section, option)
except:
return None
def saveConfig(self, section, option, value=None):
'''
保存config.ini配置文件
'''
try:
self.config.add_section(section) # 如果键值不存在，则创建键值
except:
pass
self.config.set(section, option, value)
self.config.write(open(self.file, "w+",
encoding='utf-8')) # 写入文件（读写模式）
def set_and_save(self,
option: str,
value: ConfigValue,
section=DEFSECTION) -> Tuple[str, str]:
"""
set the value in the configuration then save it
to the file
"""
# Special case for a 'toggle' value. We take the current value
# and set the opposite. Warning if the no current value exists
# or it is not a bool.
if value == "toggle":
current = self.get(option, "", section)
if isinstance(current, bool):
value = str(not current)
else:
if current.lower() == "false":
value = "true"
elif current.lower() == "true":
value = "false"
else:
return ('Could not toggle option: %s.'
' Current value is %s.' %
(option, current or "empty"), 'Warning')
if self.has_section(section):
RawConfigParser.set(self, section, option, value)
else:
self.add_section(section)
RawConfigParser.set(self, section, option, value)
if not self.write_in_file(section, option, value):
return ('Unable to write in the config file', 'Error')
return ("%s=%s" % (option, value), 'Info')
def saveConfigini():
parser = RawConfigParser()
parser.add_section('GPORTAL')
for key in configini.keys():
parser.set('GPORTAL', key, configini[key])
with open('scumlogs.ini', 'w', encoding="utf-8") as f:
parser.write(f)
def mock_config(config_dir):
data = dict(
general=dict(
conf_dir=config_dir,
verbose=True,
update_on_startup=False,
),
mpd=dict(
host='localhost',
port=6600,
),
lastfm=dict(
scrobble_days=180,
user='******',
api_key='apikey',
api_secret='secret',
),
)
config = RawConfigParser()
for section, options in data.items():
config.add_section(section)
for key, value in options.items():
config.set(section, key, value)
with NamedTemporaryFile(mode='w') as temp:
config.write(temp)
temp.flush()
with patch('suggestive.config.CONFIG_PATHS', [temp.name]):
return Config()
def set(self, option, value, section=DEFSECTION):
"""
Set the value of an option temporarily
"""
try:
RawConfigParser.set(self, section, option, value)
except NoSectionError:
pass
def setUp(self):
config = RawConfigParser()
config.read([CONFDIR + '/fuglu.conf.dist'])
config.set('main', 'disablebounces', '1')
guess_clamav_socket(config)
self.mc = MainController(config)
self.tempfiles = []
def setUp(self):
config = RawConfigParser()
config.add_section('main')
config.set('main', 'disablebounces', '1')
config.add_section('SAPlugin')
# current tests don't need config options, add them here later if
# necessary
self.config = config
def save_auth(self, username, password):
""""""
parser = RawConfigParser()
parser.add_section("AUTH")
parser.set("AUTH", "username", username)
parser.set("AUTH", "password", password)
filename = os.path.join(os.getenv("PINGUINO_USER_PATH"), "submit-auth")
parser.write(open(filename, "w"))
def create_spawn_config(self, subsystem_config):
"""Create config instance
"""
section_name = self.defaults['pki_subsystem']
cfgtpl, immutable_keys = self._get_default_config()
# overwrite CA/KRA config with subsystem settings
subsystem_config = self._mangle_values(subsystem_config)
for key, value in subsystem_config.items():
cfgtpl.set(section_name, key, value)
# get a mapping of settings that cannot be modified by users
immutable_settings = {
k: v for k, v in cfgtpl.items(section_name)
if k in immutable_keys
}
# add ipaca_customize overlay,
# These are settings that can be modified by a user, too. We use
# ipaca_customize.ini to set sensible defaults.
with open(self.ipaca_customize) as f:
cfgtpl.read_file(f)
# load external overlay from command line
if self.pki_config_override is not None:
with open(self.pki_config_override) as f:
cfgtpl.read_file(f)
# verify again
self._verify_immutable(
cfgtpl, immutable_settings, self.pki_config_override
)
# key backup is not compatible with HSM support
if (cfgtpl.has_option(section_name, 'pki_hsm_enable') and
cfgtpl.getboolean(section_name, 'pki_hsm_enable')):
cfgtpl.set(section_name, 'pki_backup_keys', 'False')
cfgtpl.set(section_name, 'pki_backup_password', '')
pki_token_name = cfgtpl.get(section_name, 'pki_token_name')
for stanza in self.token_stanzas:
if cfgtpl.has_option(section_name, stanza):
cfgtpl.set(section_name, stanza, pki_token_name)
# Next up, get rid of interpolation variables, DEFAULT,
# irrelevant sections and unused variables. Only the subsystem
# section is copied into a new raw config parser. A raw config
# parser is necessary, because ConfigParser.write() write passwords
# with '%' in a way, that is not accepted by Dogtag.
config = RawConfigParser()
config.optionxform = str
config.add_section(section_name)
for key, value in sorted(cfgtpl.items(section=section_name)):
if key.startswith('pki_'):
config.set(section_name, key, value)
return config
def write_config(self, survey_dict=None, mosaic_dict=None, constants_dict=None, spectral_dict=None,
spatial_dict=None):
"""
Writes all of the needed information to the config file called <mosaicname>.cfg
"""
if not os.path.isdir(SURVEY_CONFIG_DIR):
os.makedirs(SURVEY_CONFIG_DIR)
configfilename = survey_dict['survey'] + '_' + mosaic_dict['mosaic']
config = RawConfigParser()
config.read(configfilename + '.cfg')
if not config.has_section('survey'):
config.add_section('survey')
for variable, value in survey_dict.items():
config.set('survey', variable, value)
self.logger.info('wrote common config to ' + configfilename + '.cfg.')
if mosaic_dict:
if config.has_section('mosaic'):
self.logger.info("mosaic config exists, overwriting...")
else:
config.add_section('mosaic')
for variable, value in mosaic_dict.items():
config.set('mosaic', variable, value)
self.logger.info("wrote mosaic config to " + configfilename + ".cfg.")
if constants_dict:
if config.has_section('constants'):
self.logger.info("constants config exists, overwriting...")
else:
config.add_section('constants')
for variable, value in constants_dict.items():
config.set('constants', variable, value)
self.logger.info("wrote constants config to " + configfilename + ".cfg.")
if spectral_dict:
if config.has_section('spectralSearch'):
self.logger.info("spectralSearch config exists, overwriting...")
else:
config.add_section('spectralSearch')
for variable, value in spectral_dict.items():
config.set('spectralSearch', variable, value)
self.logger.info("wrote spectralSearch config to " + configfilename + ".cfg.")
if spatial_dict:
if config.has_section('spatialSearch'):
self.logger.info("spatialSearch config exists, overwriting...")
else:
config.add_section('spatialSearch')
for variable, value in spatial_dict.items():
config.set('spatialSearch', variable, value)
self.logger.info("wrote spatialSearch config to " + configfilename + ".cfg.")
with open(SURVEY_CONFIG_DIR + configfilename + '.cfg', 'w') as configfile:
config.write(configfile)
def silent_set(self, option, value, section=DEFSECTION):
"""
Set a value, save, and return True on success and False on failure
"""
if self.has_section(section):
RawConfigParser.set(self, section, option, value)
else:
self.add_section(section)
RawConfigParser.set(self, section, option, value)
return self.write_in_file(section, option, value)
def load(paths=()):
config = ConfigParser()
for section, values in INITIAL_CONFIG.items():
config.add_section(section)
for key, value in values.items():
config.set(section, key, value)
for path in paths:
if path:
config.read(path)
return config
def updateFile(self):
c = RawConfigParser()
c.read(self.WORK_FILE)
for i in range(0,40):
c.set("pin"+str(i),"state",str(self.currState[i]))
c.set("pin"+str(i),"value",str(self.currValue[i]))
with open(self.WORK_FILE, 'w') as configfile:
c.write(configfile)
def get_base_env(cls, name, section, options=None, server=None):
'''
Get a base environment.
'''
options = options or {}
parser = RawConfigParser()
parser.add_section(section)
for option, value in options.items():
parser.set(section, option, value)
return cls(name, parser, section, server)
def set(self,option,value=None,section=None):
if not section:
if not self.currentsection: raise configparser.NoSectionError('No Current Section Set')
section=self.currentsection
oval=RawConfigParser.get(self,section,option) if self.has_option(section,option) else None
nval=self.valtostr(value)
if oval and oval==nval: return
RawConfigParser.set(self,section,option,nval)
self.modified=True
def set(self, section, option, value):
"""
Set option in given configuration section to value.
If section does not exist yet, it is added implicitly.
"""
if not self.has_section(section):
self.add_section(section)
RawConfigParser.set(self, section, option, value)
def save_raw_parser(self, content, filename):
file_parser = RawConfigParser()
count = 0
for block in content:
count += 1
name_section = "Block-%d"%count
file_parser.add_section(name_section)
for key in block.keys():
file_parser.set(name_section, key, block[key])
file_parser.write(codecs.open(filename, "w", "utf-8"))
def set_and_save(self, option, value, section=DEFSECTION):
"""
set the value in the configuration then save it
to the file
"""
if self.has_section(section):
RawConfigParser.set(self, section, option, value)
else:
self.add_section(section)
RawConfigParser.set(self, section, option, value)
self.write_in_file(section, option, value)
def setConfigContent(self, content):
conf = RawConfigParser()
conf_file = open(self.file_path, 'w')
conf_file.write('')
conf.read(self.file_path)
for section in content:
section_items = content[section].items()
for option, value in section_items:
if conf.has_section(section) == False:
conf.add_section(section)
conf.set(section, option, value)
conf.write(open(self.file_path, "w"))
def setUp(self):
try:
from configparser import RawConfigParser
except ImportError:
from ConfigParser import RawConfigParser
config = RawConfigParser()
config.add_section('ScriptFilter')
config.set('ScriptFilter', 'scriptdir', os.path.abspath(
os.path.dirname(__file__) + '/testdata/scriptfilter'))
self.candidate = ScriptFilter(config)
def generate_token_file(self, token_file, oauth_token, oauth_token_secret):
self.oauth_token = oauth_token
self.oauth_token_secret = oauth_token_secret
conf = RawConfigParser()
conf.add_section(SECTION_TOKEN)
conf.set(SECTION_TOKEN, "oauth_token", oauth_token)
conf.set(SECTION_TOKEN, "oauth_token_secret", oauth_token_secret)
with open(token_file, "w") as tokens:
conf.write(tokens)
print(encode(_("your account has been saved")))
def write_acbs_conf():
acbs_conf_writer = RawConfigParser()
acbs_conf_writer.add_section('default')
acbs_conf_writer.set('default', 'location', '/var/lib/abbs/repo/')
acbs_conf_writer.add_section('acbs')
acbs_conf_writer.set('acbs', 'location', '/var/lib/acbs/repo/')
try:
fp = open('/etc/acbs_forest.conf', 'w')
acbs_conf_writer.write(fp)
except:
err_msg('Unable to write initial configuration file!')
return False
return True
def create_default(self):
"""
Create a default settings file
"""
config = RawConfigParser()
configfile = open(self.file_name, "w")
config.add_section('Settings')
config.set('Settings', 'dark_mode', "0")
config.add_section('Plugins')
available_plugins = ",".join(self.get_available_plugins())
config.set('Plugins', 'active_plugins', available_plugins)
config.write(configfile)
configfile.close()
def set_property(self, section, property, value):
"""
Change a property in settings ini file
"""
config = RawConfigParser()
config.read(self.file_name)
if section in config.sections():
config.set(section, property, str(value).strip())
configfile = open(self.file_name , "w")
config.write(configfile)
configfile.close()
else:
print("Error, the settings file seem to be modified manualy")
def run(self):
try:
config_file = DEFAULT_CONF_FILE
if not os.path.isfile(config_file):
raise ValueError('Configuration file not found: {0}'.format(config_file))
config = RawConfigParser()
config.read(config_file)
if 'security' in config.sections():
return 'The configuration file is already migrated to the new version'
config.add_section('security')
config.add_section('database')
for item in config.items('paths'):
if item[0] == 'database_file':
config.set('database', item[0], item[1])
else:
config.set('security', item[0], item[1])
config.remove_section('paths')
config.set('security', 'crl_file_url', 'None')
config.set('logging', 'log_level', 'INFO')
with open(config_file, 'w') as file:
config.write(file)
except Exception as exc:
return exc
return 'Configuration file migrated'
