def save_config_file():
    f = open('/app/config/app_config.ini', 'w')
    try:
        config.write(f)
        logging.debug("Configuration file successfully saved")
    finally:
        f.close()
Esempio n. 2
0
def launch(hardware):
    from hedgehog.server.hardware.simulated import SimulatedHardwareAdapter
    simulator = hardware == SimulatedHardwareAdapter

    args = parse_args(simulator)

    if args.logging_conf:
        logging.config.fileConfig(args.logging_conf)

    if simulator and args.simulate_sensors:
        _hardware = hardware

        def hardware(*args, **kwargs):
            return _hardware(*args, simulate_sensors=True, **kwargs)

    config = configparser.ConfigParser()
    config.read(args.config_file)

    if args.scan_config and os.path.isfile(args.scan_config_file):
        scan_config = configparser.ConfigParser()
        scan_config.read(args.scan_config_file)

        apply_scan_config(config, scan_config)

        with open(args.config_file, mode='w') as f:
            config.write(f)

    port = args.port or config.getint('default', 'port', fallback=0)

    with suppress(KeyboardInterrupt):
        start(hardware, port)
Esempio n. 3
0
    def __parseCfgOptions(self):
        # Is there a configuration available?
        configDir = self.get('core.config')
        configFiles = self.__getCfgFiles(os.path.join(configDir, "config.d"))
        configFiles.insert(0, os.path.join(configDir, "config"))

        config = configparser.RawConfigParser()
        filesRead = config.read(configFiles)

        # Bail out if there's no configuration file
        if not filesRead:
            raise ConfigNoFile(
                "No usable configuration file (%s/config) found!" % configDir)

        # Walk thru core configuration values and push them into the registry
        for section in config.sections():
            if not section in self.__registry:
                self.__registry[section] = {}
            self.__registry[section].update(config.items(section))

        # Initialize the logging module on the fly
        try:
            tmp = StringIO()
            config.write(tmp)
            tmp2 = StringIO(tmp.getvalue())
            logging.config.fileConfig(tmp2)

        except configparser.NoSectionError:
            logging.basicConfig(
                level=logging.ERROR,
                format='%(asctime)s (%(levelname)s): %(message)s')
Esempio n. 4
0
def check_profile_config(config):
    """
    Validation checks on the profile config. At least one profile must exist
    (otherwise exit) and the paths for each profile should exist, otherwise the
    profile entry is removed.

    Args:
        config (ConfigObj): The ConfigObj instance.
    """
    # Check that at least one profile exists
    if 'profiles' not in config:
        print('There are currently no profiles. Use "sm_profile '
              '-c <profile>" to create one.')
        sys.exit(1)
    # Check that the paths for each profile exist
    for profile in config['profiles'].keys():
        data_exists = os.path.isdir(config['profiles'][profile]['data_path'])
        delete_profile = False
        if not data_exists:
            print('Data path for profile %s does not exist.' % profile)
            delete_profile = True
        install_exists = os.path.isdir(
            config['profiles'][profile]['install_path'])
        if not install_exists:
            print('Install path for profile %s does not exist.' % profile)
            delete_profile = True
        if delete_profile:
            print('    Deleting profile %s.' % profile)
            del config['profiles'][profile]
            config.write()
    return config
Esempio n. 5
0
    def __parseCfgOptions(self):
        # Is there a configuration available?
        configDir = self.get('core.config')
        configFiles = self.__getCfgFiles(os.path.join(configDir, "config.d"))
        configFiles.insert(0, os.path.join(configDir, "config"))

        config = ConfigParser.RawConfigParser()
        filesRead = config.read(configFiles)

        # Bail out if there's no configuration file
        if not filesRead:
            raise ConfigNoFile("No usable configuration file (%s/config) found!" % configDir)

        # Walk thru core configuration values and push them into the registry
        for section in config.sections():
            if not section in self.__registry:
                self.__registry[section] = {}
            self.__registry[section].update(config.items(section))

        # Initialize the logging module on the fly
        try:
            tmp = StringIO()
            config.write(tmp)
            tmp2 = StringIO(tmp.getvalue())
            logging.config.fileConfig(tmp2)

        except ConfigParser.NoSectionError:
            logging.basicConfig(level=logging.ERROR, format='%(asctime)s (%(levelname)s): %(message)s')
Esempio n. 6
0
def check_config_file(filename='config.ini'):
    """
    checks if config.ini file exists and creates a template config file if not
    :param filename: filename of config file that is returned
    :return:
    """

    if not os.path.exists(filename):
        config = configparser.ConfigParser()
        config['TWITTER'] = {
            'consumer_key': 'your consumer key here',
            'consumer_secret': 'your consumer secret here',
            'access_token': 'your access token here',
            'access_token_secret': 'your access token secret here'
        }
        config['REDDIT'] = {
            'client_id': 'your client_id here',
            'client_secret': 'your client_secret here',
            'user_agent': 'your user_agent here'
        }
        with open(filename, 'w') as configfile:
            config.write(configfile)

        logger.info(
            'I have created a config.ini file for u. '
            'Please fill in ur twitter and reddit credensh to proceed.')

        sys.exit()
Esempio n. 7
0
def configureAPRS(args, aprsConfigPath):
    '''
    Configure aprs configuration file from command line

    :param args: argparse arguments
    :param aprsConfigPath: Path to aprs.ini file
    :return: None
    '''

    config = ConfigParser.RawConfigParser()
    config.read(os.path.join(path, "aprs.ini"))

    if args.callsign is not None:
        config.set('APRSIS', 'CALLSIGN', args.callsign)
    if args.server is not None:
        config.set('APRSIS', 'SERVER', args.server)
    if args.port is not None:
        config.set('APRSIS', 'PORT', args.port)
    if args.rate is not None:
        config.set('APRSIS', 'RATE', args.rate)
    if args.stationsage is not None:
        config.set('APRSIS', 'STATIONSAGE', args.stationsage)
    if args.comment is not None:
        config.set('APRS', 'COMMENT', args.comment[:43])
    if args.altcomment is not None:
        config.set('APRS', 'ALTCOMMENT', args.altcomment[:43])

    with open(aprsConfigPath, 'wb') as configfile:
        config.write(configfile)
Esempio n. 8
0
 def __init__(self, args, config):
     self.args = args
     self.config = config
     self.model_dir = utils.get_model_dir(config)
     self.cache_dir = utils.get_cache_dir(config)
     self.category = utils.get_category(config, self.cache_dir)
     self.anchors = torch.from_numpy(utils.get_anchors(config)).contiguous()
     logging.info('use cache directory ' + self.cache_dir)
     logging.info('tensorboard --logdir ' + self.model_dir)
     if args.delete:
         logging.warning('delete model directory: ' + self.model_dir)
         shutil.rmtree(self.model_dir, ignore_errors=True)
     os.makedirs(self.model_dir, exist_ok=True)
     with open(self.model_dir + '.ini', 'w') as f:
         config.write(f)
     self.saver = utils.train.Saver(self.model_dir,
                                    config.getint('save', 'keep'))
     self.timer_save = utils.train.Timer(config.getfloat('save', 'secs'),
                                         False)
     try:
         self.timer_eval = utils.train.Timer(
             eval(config.get('eval', 'secs')),
             config.getboolean('eval', 'first'))
     except configparser.NoOptionError:
         self.timer_eval = lambda: False
     self.summary_worker = SummaryWorker(self)
     self.summary_worker.start()
Esempio n. 9
0
def write():
    if not os.path.isdir(os.path.dirname(configs_found[-1])):
        os.mkdir(os.path.dirname(configs_found[-1]))

    f = open(configs_found[-1], 'w')
    config.write(f)
    f.close()
Esempio n. 10
0
def try_enroll_in_operation_mode(device_id, dev):
    enroll_token = get_enroll_token()
    if enroll_token is None:
        return
    logger.info("Enroll token found. Trying to automatically enroll the node.")

    setup_endpoints(dev)
    response = mtls_request('get',
                            'claimed',
                            dev=dev,
                            requester_name="Get Node Claim Info")
    if response is None or not response.ok:
        logger.error('Did not manage to get claim info from the server.')
        return
    logger.debug("[RECEIVED] Get Node Claim Info: {}".format(response))
    claim_info = response.json()
    if claim_info['claimed']:
        logger.info('The node is already claimed. No enrolling required.')
    else:
        claim_token = claim_info['claim_token']
        if not enroll_device(enroll_token, claim_token, device_id):
            logger.error('Node enrolling failed. Will try next time.')
            return

    logger.info("Update config...")
    config = configparser.ConfigParser()
    config.read(INI_PATH)
    config.remove_option('DEFAULT', 'enroll_token')
    with open(INI_PATH, 'w') as configfile:
        config.write(configfile)
    os.chmod(INI_PATH, 0o600)
Esempio n. 11
0
def index():
    username = request.cookies.get('username')
    if username:
        logging.info("{} accessing the page".format(username))
    else:
        logging.info("Unknown user accessing the page")

    config.read(status_file_path)
    error = False

    version = subprocess.check_output(["git", "describe",
                                       "--always"]).strip().decode("utf-8")

    if request.method == "POST":
        if request.form["action"] == "login":
            username = request.form.get('username')
            logging.info("Logged in with {}".format(username))
            resp = make_response(redirect('/'))
            resp.set_cookie('username', username)
            return resp

        if request.form["action"] == "logout":
            logging.info("{} Logging out".format(username))
            resp = make_response(redirect('/'))
            resp.delete_cookie('username')
            return resp

        if request.form["action"] == "release":
            logging.info("Attempting to set cow free status")
            logging.info("Setting cow free status: True")
            config["Cow"]["Free"] = "True"
            config["Cow"]["Owner"] = ""
            with open(status_file_path, "w") as configfile:
                config.write(configfile)

        if request.form["action"] == "acquire":
            logging.info("Attempting to set cow free status")
            if config["Cow"]["Free"] == "False":
                logging.info("Cow already acquired by {}".format(
                    config["Cow"]["Owner"]))
                error = True
            else:
                logging.info("Setting cow free status: False")
                config["Cow"]["Free"] = "False"
                config["Cow"]["Owner"] = username
                with open(status_file_path, "w") as configfile:
                    config.write(configfile)

    if username:
        return render_template('index.html',
                               version=version,
                               username=username,
                               cow_free=config["Cow"]["Free"] == "True",
                               cow_owner=config["Cow"]["Owner"],
                               error=error)
    return render_template('index.html',
                           version=version,
                           cow_free=config["Cow"]["Free"] == "True",
                           cow_owner=config["Cow"]["Owner"])
Esempio n. 12
0
def create_default_config(config):
    config['DEFAULT'] = {
        'crontab_path': 'crontab',
        'logger_config': 'logger_config.conf',
        'logger_name': 'logger'
    }
    with open(config_file, 'w') as configfile:
        config.write(configfile)
Esempio n. 13
0
    def gtk_main_quit(self, window):
        """ Quit the application """
        Gtk.main_quit()

        # Save current configuration
        with open(CONFIG_FILE, 'wb') as configfile:
            config.write(configfile)
        log.debug("Config written to: %s" %CONFIG_FILE)
Esempio n. 14
0
    def gtk_main_quit(self, window):
        """ Quit the application """
        Gtk.main_quit()

        # Save current configuration
        with open(CONFIG_FILE, 'wb') as configfile:
            config.write(configfile)
        log.debug("Config written to: %s" % CONFIG_FILE)
Esempio n. 15
0
def run_tribler_core_session(api_port,
                             api_key,
                             state_dir,
                             gui_test_mode=False):
    """
    This method will start a new Tribler session.
    Note that there is no direct communication between the GUI process and the core: all communication is performed
    through the HTTP API.
    """
    logger.info(f'Start tribler core. API port: "{api_port}". '
                f'API key: "{api_key}". State dir: "{state_dir}". '
                f'Core test mode: "{gui_test_mode}"')

    config = TriblerConfig.load(file=state_dir / CONFIG_FILE_NAME,
                                state_dir=state_dir,
                                reset_config_on_error=True)
    config.gui_test_mode = gui_test_mode

    if SentryReporter.is_in_test_mode():
        default_core_exception_handler.sentry_reporter.global_strategy = SentryStrategy.SEND_ALLOWED

    config.api.http_port = int(api_port)
    # If the API key is set to an empty string, it will remain disabled
    if config.api.key not in ('', api_key):
        config.api.key = api_key
        config.write(
        )  # Immediately write the API key so other applications can use it
    config.api.http_enabled = True

    priority_order = config.resource_monitor.cpu_priority
    set_process_priority(pid=os.getpid(), priority_order=priority_order)

    # Enable tracer if --trace-debug or --trace-exceptions flag is present in sys.argv
    log_dir = config.general.get_path_as_absolute('log_dir', config.state_dir)
    trace_logger = check_and_enable_code_tracing('core', log_dir)

    logging.getLogger('asyncio').setLevel(logging.WARNING)

    if sys.platform.startswith('win'):
        # TODO for the moment being, we use the SelectorEventLoop on Windows, since with the ProactorEventLoop, ipv8
        # peer discovery becomes unstable. Also see issue #5485.
        asyncio.set_event_loop(asyncio.SelectorEventLoop())

    loop = asyncio.get_event_loop()
    exception_handler = default_core_exception_handler
    loop.set_exception_handler(exception_handler.unhandled_error_observer)

    try:
        loop.run_until_complete(
            core_session(config, components=list(components_gen(config))))
    finally:
        if trace_logger:
            trace_logger.close()

        # Flush the logs to the file before exiting
        for handler in logging.getLogger().handlers:
            handler.flush()
Esempio n. 16
0
    def set_server(self, ip, port):
        config = self._config
        if 'SERVER' not in config.keys():
            config['SERVER'] = {}
        config['SERVER']['ip'] = ip
        config['SERVER']['port'] = str(port)

        with open(self.filename, 'w') as f:
            config.write(f)
Esempio n. 17
0
 def create_default_configuration(cls, default_profile_url):
     """ensure a default profile is configured."""
     config_directory = cls._ensure_configuration_directory()
     config = ConfigParser()
     config.add_section('default')
     config.set('default', 'repository', default_profile_url)
     with open(os.path.join(config_directory, 'profiles'),
               'w') as profiles_file:
         config.write(profiles_file)
     return cls()
Esempio n. 18
0
 def log_location_update():
     config = configparser.ConfigParser()
     config.read(f"{Common.config_path}/logger.ini")
     config.set(
         "handler_fileHandler",
         "args",
         f"('{Common.report_path}/Automation.log', 'a')",
     )
     with open(f"{Common.config_path}/logger.ini", "w") as f:
         config.write(f)
Esempio n. 19
0
    def set_mrouter(self, id, ip, port):
        config = self._config
        if 'MROUTER' not in config.keys():
            config['MROUTER'] = {}
        config['MROUTER']['id'] = id
        config['MROUTER']['ip'] = ip
        config['MROUTER']['port'] = str(port)

        with open(self.filename, 'w') as f:
            config.write(f)
Esempio n. 20
0
def config_write(config):
    os.system("cp %s %s" % (sololink_conf, sololink_back))
    os.system("md5sum %s > %s.md5" % (sololink_back, sololink_back))
    os.system("sync")
    f = open(sololink_conf, 'wb')
    config.write(f)
    f.close()
    os.system("md5sum %s > %s.md5" % (sololink_conf, sololink_conf))
    os.system("sync")
    os.system("rm %s %s.md5" % (sololink_back, sololink_back))
Esempio n. 21
0
 def _create_log_config(self, config_filename, log_filename, level):
     template_fname = self.get_template_fname()
     template = open(template_fname)
     config = open(config_filename, 'w')
     config.truncate()
     for line in template:
         config.write(
             line.replace('@@LEVEL@@',
                          level).replace('@@FILENAME@@', log_filename))
     config.close()
     template.close()
Esempio n. 22
0
    def set_config(cls, key, value, config_file=None):

        if config_file is None:
            config_file = cls.def_config_file

        if key not in cls.allowed_configuration_keys:
            raise PowergloveError('%r not an allowed configuration key. Possible values are %s' %
                                  (key, ', '.join(cls.allowed_configuration_keys)))

        config = configobj.ConfigObj(config_file)
        config[key] = value
        config.write()
Esempio n. 23
0
    def _setup_system(self):
        config_dir = utils.Utils().get_app_dir()
        config_path = os.path.join(config_dir, '.guardiancl.ini')
        if not os.path.exists(config_path):
            config = configparser2.ConfigParser()
            config.add_section('ROUTES')
            config.set('ROUTES', 'auth', 'http://guardiaocloud.com.br/service/v1/authenticate')
            config.set('ROUTES', 'devices', 'http://guardiaocloud.com.br/service/v1/devices')
            config.set('ROUTES', 'collect', 'http://guardiaocloud.com.br/collect')

            with open(config_path, 'w') as configfile:
                config.write(configfile)
Esempio n. 24
0
 def writeConfig(self):
     '''
     This function creates / saves log settings to a file.
     '''
     config = ConfigParser.ConfigParser()
     config.add_section('loggers')
     config.set('loggers', 'keys', 'root')
     
     config.add_section('formatters')
     config.set('formatters', 'keys', 'basic,nix')
     
     config.add_section('handlers')
     config.set('handlers', 'keys', 'consoleHandler,syslogHandler')
     
     config.add_section('logger_root')
     config.set('logger_root', 'level', 'DEBUG')
     config.set('logger_root', 'handlers', 'consoleHandler')
     
     config.add_section('handler_consoleHandler')
     config.set('handler_consoleHandler', 'class', 'StreamHandler')
     config.set('handler_consoleHandler', 'level', 'NOTSET')
     config.set('handler_consoleHandler', 'formatter', 'basic')
     config.set('handler_consoleHandler', 'args', '(sys.stdout,)')
     
     config.add_section('handler_syslogHandler')
     config.set('handler_syslogHandler', 'level', 'NOTSET')
     if sys.platform.startswith('linux'):
         config.set('handler_syslogHandler', 'class', 'handlers.SysLogHandler')
         config.set('handler_syslogHandler', 'formatter', 'nix')
         config.set('handler_syslogHandler', 'args', "("+self.getLogPath()+", handlers.SysLogHandler.LOG_USER)")
     elif sys.platform == 'win32' or sys.platform == 'cygwin':
         config.set('handler_syslogHandler', 'class', 'handlers.NTEventLogHandler')
         config.set('handler_syslogHandler', 'formatter', 'nix')
         config.set('handler_syslogHandler', 'args', "('Freeseer', '', 'Application')")
     elif sys.platform =='darwin':
         config.set('handler_syslogHandler', 'class', 'handlers.SysLogHandler')
         config.set('handler_syslogHandler', 'formatter', 'nix')
         config.set('handler_syslogHandler', 'args', "("+self.getLogPath()+", handlers.SysLogHandler.LOG_USER)")
         #config.set('handler_syslogHandler', 'args', "(('/dev/log'), handlers.SysLogHandler.LOG_USER)")
     else:
         pass # Unsupported
     
     config.add_section('formatter_basic')
     config.set('formatter_basic', 'format', '%(asctime)s freeseer: <%(levelname)s> %(message)s')
     config.set('formatter_basic', 'datefmt', '%Y-%m-%d %H:%M:%S')
     
     config.add_section('formatter_nix')
     config.set('formatter_nix', 'format', 'freeseer: <%(levelname)s> %(message)s')
     
     # Save default settings to new config file
     with open(self.logconf, 'w') as configfile:
         config.write(configfile)
Esempio n. 25
0
def write_config(albumNum, trackNum):
    # Add content to the file
    config = ConfigParser.ConfigParser()
    config.add_section('cdc')
    config.set('cdc', 'album', albumNum)
    config.set('cdc', 'track', trackNum)

    # Create the configuration file as it doesn't exist yet
    with open(CONFIG, 'w') as file:
        config.write(file)

    logger.info('write config album: {}, track: {}'.format(albumNum, trackNum))
    return
Esempio n. 26
0
def write_config_to_filename(config_dictionary, config_filename):
    config = SafeConfigParser()
    for section in config_dictionary:
        config.add_section(section)
        variables = config_dictionary[section]
        for v in variables:
            config.set(section, v, variables[v])
    mode = stat.S_IRUSR | stat.S_IWUSR
    flags = os.O_WRONLY | os.O_CREAT | os.O_EXCL
    fd = os.open(config_filename, flags, mode)
    f = os.fdopen(fd, 'wb')
    config.write(f)
    f.close()
Esempio n. 27
0
    def write_config(cls, config: configparser.ConfigParser, identifier: str, prefix="configs_byserial"):
        """
        writes a configuration file to an correct config file path.

        :param config: configuration file (configparser object)
        :type identifier: str
        :param identifier: identifier to user as the raget file name.
        :return: configparser object
        """
        path = SysUtil.identifier_to_ini(identifier, prefix=prefix)
        with open(path, 'w+') as configfile:
            config.write(configfile)
        return config
    def write_light_config(cls, config: configparser.ConfigParser, identifier: str):
        """
        writes a configuration file to an correct config file path.

        :param config: configuration file (configparser object)
        :param identifier: identifier of the light.
        :type identifier: str
        :return: configparser object
        """
        path = SysUtil.light_identifier_to_ini(identifier)
        with open(path, 'w+') as configfile:
            config.write(configfile)
        return config
Esempio n. 29
0
def writeDefaultConfig():
	logger.debug('No config found. Writing default config to server.cfg. Please adapt accordingly and restart the server.')
	config = configparser.ConfigParser()
	config['Server'] = {
		'host': 'localhost',
		'port': '8080'
	}
	config['HueBridge'] = {
		'ip': '192.168.0.x',
		'user': '******'
	}
	with open('server.cfg', 'w') as configfile:
		config.write(configfile)
Esempio n. 30
0
    def set_config(cls, key, value, config_file=None):

        if config_file is None:
            config_file = cls.def_config_file

        if key not in cls.allowed_configuration_keys:
            raise PowergloveError(
                '%r not an allowed configuration key. Possible values are %s' %
                (key, ', '.join(cls.allowed_configuration_keys)))

        config = configobj.ConfigObj(config_file)
        config[key] = value
        config.write()
Esempio n. 31
0
def read_or_create_config_file(
        path_to_configfile: Path) -> configparser.ConfigParser:
    """
    Creates config file with default values
    or reads the current config file "config.ini".
    """
    config = configparser.ConfigParser(allow_no_value=True)
    config.optionxform = str
    if not path_to_configfile.is_file():
        config.add_section("Basics")
        config.set("Basics", "# Settings related to the playfield window")
        config.set("Basics", "columns", "10")
        config.set("Basics", "rows", "24")
        config.set("Basics", "fraction_of_vres", "30")
        config.set("Basics", "x_position", "26")
        config.set("Basics", "y_position", "3")
        config.set("Basics", "spawn_row", "3")
        config.set("Basics", "spawn_column", "4")
        config.add_section("Fonts")
        config.set("Fonts", "# Path to the fontfile")
        config.set("Fonts", "file", "fonts/codeman38_deluxefont/dlxfont.ttf")
        config.set("Fonts", "# Default font size")
        config.set("Fonts", "size_fraction_of_vres", "67.5")
        config.add_section("Game_window")
        config.set("Game_window", "# Game Window Title")
        config.set("Game_window", "title", "Pygtris")
        config.set("Game_window", "# Initial Game Window Position")
        config.set("Game_window", "horizontal", "0")
        config.set("Game_window", "vertical", "0")
        config.set("Game_window", "# Game Window Size")
        config.set("Game_window", "width", "1920")
        config.set("Game_window", "height", "1080")
        config.add_section("Technical")
        config.set("Technical", "# Framerate Limit")
        config.set("Technical", "framerate", "100")
        config.add_section("Graphics")
        config.set("Graphics", "folder", "img")
        config.set("Graphics", "empty_playfield_tile",
                   "opaque_playfield_tile.png")
        config.add_section("Colors")
        config.set(
            "Colors",
            "# Color values need to be separated by comma and space \", \"")
        config.set("Colors", "game_window_background_color", "18, 18, 18, 255")
        config.set("Colors", "game_window_foreground_color",
                   "245, 245, 245, 255")
        config.set("Colors", "font_color", "70, 70, 70, 255")
        with open(path_to_configfile, mode="w", encoding="utf-8") as configfh:
            config.write(configfh)
    config.read(path_to_configfile)
    return config
Esempio n. 32
0
File: cdc.py Progetto: oritomov/cdc
def write_config(albumNum, trackNum):

	# Add content to the file
	config = ConfigParser.ConfigParser()
	config.add_section('cdc')
	config.set('cdc', 'album', albumNum)
	config.set('cdc', 'track', trackNum)

	# Create the configuration file as it doesn't exist yet
	with open(CONFIG, 'w') as file:
		config.write(file)

	logger.info('write config album: {}, track: {}'.format(albumNum, trackNum))
	return
Esempio n. 33
0
 def writeDefaultConfig(config):
     config.add_section('STORAGE')
     storageConfig                   = config['STORAGE']
     storageConfig['data_path']      = 'data/storage/'
     config.add_section('TASK_MANAGER')
     config.add_section('SERVER')
     config.add_section('SCHEDULER')
     config.add_section('LOGGING')
     loggingConfig                   = config['LOGGING']
     loggingConfig['file']           = CONFIG_PATH + '/logging.conf'
     if not os.path.exists(CONFIG_PATH):
         os.makedirs(CONFIG_PATH)
     with open(CONFIG_FILE,'w') as configFile:        
         config.write(configFile)
Esempio n. 34
0
def updateLogConfig(fileName, loggerName):
    try:
      config = openLogConfig(fileName)
      config.set('loggers', 'keys', config.get('loggers', 'keys')+','+loggerName)
      print 'new logger names:',config.get('loggers', 'keys')
      config.add_section('logger_'+loggerName)
      config.set('logger_'+loggerName, 'handlers', 'consoleHandler')
      config.set('logger_'+loggerName, 'propagate', '0')
      config.set('logger_'+loggerName, 'level', 'ERROR')
      config.set('logger_'+loggerName, 'qualname', loggerName)
      configfile = open(fileName, 'wb')
      config.write(configfile)
    except:
      pass
Esempio n. 35
0
    def __parseCfgOptions(self):
        # Is there a configuration available?
        configDir = self.get('core.config')
        configFiles = self.__getCfgFiles(os.path.join(configDir, "config.d"))
        configFiles.insert(0, os.path.join(configDir, "config"))

        config = configparser.RawConfigParser()
        filesRead = config.read(configFiles)

        # Bail out if there's no configuration file
        if not filesRead:
            raise ConfigNoFile(
                "No usable configuration file (%s/config) found!" % configDir)

        # Walk thru core configuration values and push them into the registry
        for section in config.sections():
            if not section in self.__registry:
                self.__registry[section] = {}
            self.__registry[section].update(config.items(section))

        if not hasattr(sys, "_called_from_test") or getattr(
                sys, "_called_from_test") is False:
            # do not use this in tests
            self.__user_config = configparser.RawConfigParser()
            # read the settings changed via gui client
            if os.path.exists(
                    os.path.join(self.get('core.user-config'), "user-config")):
                filesRead = self.__user_config.read(
                    os.path.join(self.get('core.user-config'), "user-config"))
                if not filesRead:
                    raise ConfigNoFile(
                        "No usable GUI configuration file (%s/user-config) found!"
                        % configDir)

        # Initialize the logging module on the fly
        try:
            if self.__user_config is not None:
                for section in self.__user_config.sections():
                    for option, value in self.__user_config.items(section):
                        config.set(section, option, value)

            tmp = StringIO()
            config.write(tmp)
            tmp2 = StringIO(tmp.getvalue())
            logging.config.fileConfig(tmp2)

        except configparser.NoSectionError:
            logging.basicConfig(
                level=logging.ERROR,
                format='%(asctime)s (%(levelname)s): %(message)s')
Esempio n. 36
0
def create_shanghai_config() -> None:
    """Create an empty shanghai config with necessary sections and keys."""
    config = configparser.ConfigParser()
    config["DEFAULT"] = {
        "owner": "",
        "nick": "",
        "realname": "",
        "password": "",
        "prefix": ",",
        "server": "",
        "port": "6697",
        "ssl": "yes",
    }
    with open("config/shanghai.ini", "w+") as conffile:
        config.write(conffile)
Esempio n. 37
0
 def change_server_name(self, new_name):
     with invalidates(Rcon.get_name):
         remote_path = f"{self.base_path}/ServerConfig/Server.ini"
         logger.info("Updating name in %s", remote_path)
         f = BytesIO()
         self.adapter.get_file(remote_path, f)
         print(f.getvalue())
         config = ConfigParser()
         config.read_string(f.getvalue().decode())
         config.set("Server", "Name", f'"{new_name}"')
         temp_f = StringIO()
         config.write(temp_f)
         f = BytesIO(temp_f.getvalue().encode())
         self.adapter.put_file(f, remote_path)
         logger.info("Updated name to %s", new_name)
Esempio n. 38
0
    def _setup_system(self):
        config_dir = utils.Utils().get_app_dir()
        config_path = os.path.join(config_dir, '.guardiancl.ini')
        if not os.path.exists(config_path):
            config = configparser2.ConfigParser()
            config.add_section('ROUTES')
            config.set('ROUTES', 'auth',
                       'http://guardiaocloud.com.br/service/v1/authenticate')
            config.set('ROUTES', 'devices',
                       'http://guardiaocloud.com.br/service/v1/devices')
            config.set('ROUTES', 'collect',
                       'http://guardiaocloud.com.br/collect')

            with open(config_path, 'w') as configfile:
                config.write(configfile)
Esempio n. 39
0
    def writeConfig(self):
        config = ConfigParser()

        for keysym, action in self.__macros.items():
            config[keysym] = action

        try:
            with open(self.__configFile, 'w') as fic:
                config.write(fic)
        except:
            self.log('Write error on config file'.format(self.__configFile),
                     cat='error')
            self.notify.send('Write error on config file <b>{}</b>'.format(
                self.__configFile))
            exit(2)
Esempio n. 40
0
def main():
    args = make_args()
    config = configparser.ConfigParser()
    utils.load_config(config, args.config)
    for cmd in args.modify:
        utils.modify_config(config, cmd)
    with open(os.path.expanduser(os.path.expandvars(args.logging)), 'r') as f:
        logging.config.dictConfig(yaml.load(f))
    if args.run is None:
        buffer = io.StringIO()
        config.write(buffer)
        args.run = hashlib.md5(buffer.getvalue().encode()).hexdigest()
    logging.info('cd ' + os.getcwd() + ' && ' + subprocess.list2cmdline([sys.executable] + sys.argv))
    train = Train(args, config)
    train()
    logging.info(pybenchmark.stats)
Esempio n. 41
0
class AppLogger:
    """
        Application log
    """
    working_dir = os.path.dirname(__file__).replace('libcommon','')
    __log_single = None
    __log_ini_file_temp = os.path.join(working_dir,'conf/log/log_config_temp.conf')
    __log_ini_file = os.path.join(working_dir,'conf/log/log_config.conf')
    filecontent = open(__log_ini_file_temp,'rb')
    config = ConfigParser.ConfigParser()
    config.readfp(filecontent)
    filecontent.close()
    config.set("handler_file","args",(os.path.join(working_dir,'log/app.log'),'d',1,'%Y-%m-%d'))
    configContent = open(__log_ini_file,'wb')
    config.write(configContent)
    configContent.close()
    def __init__(self):
        if not AppLogger.__log_single:
            try:
                logging.config.fileConfig(AppLogger.__log_ini_file)
            except:
                pass
            AppLogger.__log_single = logging.getLogger(None)
            
    def getHandler(self):
        return AppLogger.__log_single
Esempio n. 42
0
def main():
    args = make_args()
    config = configparser.ConfigParser()
    utils.load_config(config, args.config)
    for cmd in args.modify:
        utils.modify_config(config, cmd)
    with open(os.path.expanduser(os.path.expandvars(args.logging)), 'r') as f:
        logging.config.dictConfig(yaml.load(f))
    if args.run is None:
        buffer = io.StringIO()
        config.write(buffer)
        args.run = hashlib.md5(buffer.getvalue().encode()).hexdigest()
    logging.info('cd ' + os.getcwd() + ' && ' + subprocess.list2cmdline([sys.executable] + sys.argv))
    train = Train(args, config)
    train()
    logging.info(pybenchmark.stats)
Esempio n. 43
0
async def core_session(config: TriblerConfig, components: List[Component]):
    session = Session(config, components, failfast=False)
    signal.signal(signal.SIGTERM,
                  lambda signum, stack: session.shutdown_event.set)
    async with session.start() as session:
        # If there is a config error, report to the user via GUI notifier
        if config.error:
            session.notifier[notifications.report_config_error](config.error)

        # SHUTDOWN
        await session.shutdown_event.wait()

        if not config.gui_test_mode:
            session.notifier[notifications.tribler_shutdown_state](
                "Saving configuration...")
            config.write()
Esempio n. 44
0
    def write_config(cls,
                     config: configparser.ConfigParser,
                     identifier: str,
                     prefix="configs_byserial"):
        """
        writes a configuration file to an correct config file path.

        :param config: configuration file (configparser object)
        :type identifier: str
        :param identifier: identifier to user as the raget file name.
        :return: configparser object
        """
        path = SysUtil.identifier_to_ini(identifier, prefix=prefix)
        with open(path, 'w+') as configfile:
            config.write(configfile)
        return config
Esempio n. 45
0
    def __parseCfgOptions(self):
        # Is there a configuration available?
        configDir = self.get('core.config')
        configFiles = self.__getCfgFiles(os.path.join(configDir, "config.d"))
        configFiles.insert(0, os.path.join(configDir, "config"))

        config = configparser.RawConfigParser()
        filesRead = config.read(configFiles)

        # Bail out if there's no configuration file
        if not filesRead:
            raise ConfigNoFile("No usable configuration file (%s/config) found!" % configDir)

        # Walk thru core configuration values and push them into the registry
        for section in config.sections():
            if not section in self.__registry:
                self.__registry[section] = {}
            self.__registry[section].update(config.items(section))

        if not hasattr(sys, "_called_from_test") or getattr(sys, "_called_from_test") is False:
            # do not use this in tests
            self.__user_config = configparser.RawConfigParser()
            # read the settings changed via gui client
            if os.path.exists(os.path.join(self.get('core.user-config'), "user-config")):
                filesRead = self.__user_config.read(os.path.join(self.get('core.user-config'), "user-config"))
                if not filesRead:
                    raise ConfigNoFile("No usable GUI configuration file (%s/user-config) found!" % configDir)

        # Initialize the logging module on the fly
        try:
            if self.__user_config is not None:
                for section in self.__user_config.sections():
                    for option, value in self.__user_config.items(section):
                        config.set(section, option, value)

            tmp = StringIO()
            config.write(tmp)
            tmp2 = StringIO(tmp.getvalue())
            logging.config.fileConfig(tmp2)

        except configparser.NoSectionError:
            logging.basicConfig(level=logging.ERROR, format='%(asctime)s (%(levelname)s): %(message)s')
Esempio n. 46
0
 def set_syslog_logger(self, enabled):
     config = ConfigParser.ConfigParser()
     config.readfp(open(self.logconf))
     handlers = config.get("logger_root", "handlers")
     handler_list = handlers.split(',')
     
     if enabled:
         new_list = "syslogHandler,"
     else:
         new_list = ""
     
     for handler in handler_list:
         if handler == "syslogHandler": continue
         new_list += handler + ","
     new_list = new_list.rstrip(',')
     
     config.set("logger_root", "handlers", new_list)
     
     with open(self.logconf, 'w') as configfile:
         config.write(configfile)
Esempio n. 47
0
    def write_report_details(self):

        phy_topology = self._get_phy_topology_detail()

        details_h = open(self.report_details_file, 'w')
        config = ConfigParser.ConfigParser()
        config.add_section('Test')
        config.set('Test', 'Build', self.build_id)
        config.set('Test', 'timestamp', self.ts)
        config.set('Test', 'Report', self.html_log_link)
        config.set('Test', 'LogsLocation', self.log_link)
        config.set('Test', 'Topology', phy_topology)
        config.write(details_h)

        log_location = ''
        if self.jenkins_trigger:
            log_location = "nodeb10.englab.juniper.net:/cs-shared/test_runs" \
                "/%s/%s" % (self.host_data[self.cfgm_ips[0]]['name'], self.ts) 
            config.set('Test', 'CoreLocation', log_location)

        details_h.close()
Esempio n. 48
0
 def writeDefaultConfig(config):
     config.add_section('STORAGE')
     storageConfig                   = config['STORAGE']
     storageConfig['data_path']      = 'data/storage/'
     config.add_section('SCHEDULER')
     config.add_section('TASK_MANAGER')
     config.add_section('INTERFACE')
     config.add_section('CONTRACTOR')
     config.add_section('ENTITY_MANAGER')
     interfaceConfig                 = config['INTERFACE']
     interfaceConfig['xmlrpc_server_addr'] = 'localhost'
     interfaceConfig['xmlrpc_server_port'] = '8000' 
     config.add_section('LOGGING')
     loggingConfig                   = config['LOGGING']
     loggingConfig['file']           = CONFIG_PATH + '/logging.conf'
     
     if not os.path.exists(CONFIG_PATH):
         os.makedirs(CONFIG_PATH)        
     
     with open(CONFIG_FILE,'w') as configFile:        
         config.write(configFile)
Esempio n. 49
0
 def writeConfig(self):
     '''
     This function creates / saves log settings to a file.
     '''
     config = ConfigParser.ConfigParser()
     config.add_section('loggers')
     config.set('loggers', 'keys', 'root')
     
     config.add_section('formatters')
     config.set('formatters', 'keys', 'basic,nix')
     
     config.add_section('handlers')
     config.set('handlers', 'keys', 'consoleHandler,syslogHandler')
     
     config.add_section('logger_root')
     config.set('logger_root', 'level', 'DEBUG')
     config.set('logger_root', 'handlers', 'consoleHandler,syslogHandler')
     
     config.add_section('handler_consoleHandler')
     config.set('handler_consoleHandler', 'class', 'StreamHandler')
     config.set('handler_consoleHandler', 'level', 'NOTSET')
     config.set('handler_consoleHandler', 'formatter', 'basic')
     config.set('handler_consoleHandler', 'args', '(sys.stdout,)')
     
     config.add_section('handler_syslogHandler')
     config.set('handler_syslogHandler', 'class', 'handlers.SysLogHandler')
     config.set('handler_syslogHandler', 'level', 'NOTSET')
     config.set('handler_syslogHandler', 'formatter', 'nix')
     config.set('handler_syslogHandler', 'args', "(('/dev/log'), handlers.SysLogHandler.LOG_USER)")
     
     config.add_section('formatter_basic')
     config.set('formatter_basic', 'format', '%(asctime)s freeseer: <%(levelname)s> %(message)s')
     config.set('formatter_basic', 'datefmt', '%Y-%m-%d %H:%M:%S')
     
     config.add_section('formatter_nix')
     config.set('formatter_nix', 'format', 'freeseer: <%(levelname)s> %(message)s')
     
     # Save default settings to new config file
     with open(self.logconf, 'w') as configfile:
         config.write(configfile)
Esempio n. 50
0
 def __init__(self, args, config):
     self.args = args
     self.config = config
     self.model_dir = utils.get_model_dir(config)
     self.cache_dir = utils.get_cache_dir(config)
     self.category = utils.get_category(config, self.cache_dir)
     self.anchors = torch.from_numpy(utils.get_anchors(config)).contiguous()
     logging.info('use cache directory ' + self.cache_dir)
     logging.info('tensorboard --logdir ' + self.model_dir)
     if args.delete:
         logging.warning('delete model directory: ' + self.model_dir)
         shutil.rmtree(self.model_dir, ignore_errors=True)
     os.makedirs(self.model_dir, exist_ok=True)
     with open(self.model_dir + '.ini', 'w') as f:
         config.write(f)
     self.saver = utils.train.Saver(self.model_dir, config.getint('save', 'keep'))
     self.timer_save = utils.train.Timer(config.getfloat('save', 'secs'), False)
     try:
         self.timer_eval = utils.train.Timer(eval(config.get('eval', 'secs')), config.getboolean('eval', 'first'))
     except configparser.NoOptionError:
         self.timer_eval = lambda: False
     self.summary_worker = SummaryWorker(self)
     self.summary_worker.start()
Esempio n. 51
0
    def __parseCfgOptions(self):
        # Is there a configuration available?
        configFile = self.get('core.config')
        configFiles = self.__getCfgFiles(configFile + ".d")
        configFiles.insert(0, configFile)

        config = ConfigParser.RawConfigParser()
        filesRead = config.read(configFiles)

        # Bail out if there's no configuration file
        if not filesRead:
            raise ConfigNoFile("No usable configuration file (%s) found!" % configFile)

        # Walk thru core configuration values and push them into the registry
        for section in config.sections():
            if not section in self.__registry:
                self.__registry[section] = {}
            self.__registry[section].update(config.items(section))

        # Initialize the logging module on the fly
        tmp = StringIO.StringIO()
        config.write(tmp)
        tmp2 = StringIO.StringIO(tmp.getvalue())
        logging.config.fileConfig(tmp2)
Esempio n. 52
0
def ConfigParserConfig(config, disable_existing_loggers=False):
    """
    config from a ConfigParser object
    :param config:
    :param disable_existing_loggers:
    """
    # logging config uses 0 and 1 instead of True and False
    disable_existing_loggers = disable_existing_loggers and 1 or 0

    memfile = StringIO.StringIO()
    config.write(memfile)
    memfile.seek(0)
    try:
        if sys.version_info >= (2,6):
            logging.config.fileConfig(memfile,
                                      disable_existing_loggers=disable_existing_loggers)
        else:
            disableds = {}
            #noinspection PyUnresolvedReferences
            for key, value in logging.root.manager.loggerDict.items():
                try:
                    disableds[key] = value.disabled or disable_existing_loggers
                except AttributeError:
                    # This is OK, we're dealing with a LoggerPlaceholder which
                    #doesn't have 'disabled' defined. logging.config.fileConfig
                    #defines them as 1 anyways, so by default, we want to enable
                    #them
                    disableds[key] = disable_existing_loggers
            logging.config.fileConfig(memfile)
            for key, disabled in disableds.items():
                #noinspection PyUnresolvedReferences
                logging.root.manager.loggerDict[key].disabled = disabled
    except socket.error, e:
        sys.stderr.write("Error occurs when initialize logging: ")
        sys.stderr.write(str(e))
        sys.stderr.write(os.linesep)
Esempio n. 53
0
 def write(path, section, key, value):
     config = ConfigParser()
     config.read(path)
     config[section][key] = value
     with open(path, 'w') as configfile:
         config.write(configfile)
Esempio n. 54
0
    auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
    
    if not access_key or not access_secret:
        # OAuth dance
        try:
            redirect_url = auth.get_authorization_url()
            print 'Go here to get the OAuth PIN! %s'%redirect_url
        except tweepy.TweepError:
            twlogger.error('Error! Failed to get request token.')
            sys.exit(1)
        
        verifier = raw_input('Verifier: ')
        auth.get_access_token(verifier)
        config.set('Twitter','access_key',auth.access_token.key)
        config.set('Twitter','access_secret',auth.access_token.secret)
        config.write(open('conf/twitterbot.ini','w'))
        sys.exit(0)
    else:
        auth.set_access_token(access_key,access_secret)
    
    api = tweepy.API(auth)
    
    ivy_name = config.get('Twitter','ivy_name')
    IvyInit(ivy_name,'[%s is ready]'%ivy_name,0,oncxproc,ondieproc)
    IvyStart(config.get('General','ivy_bus'))
    IvyBindMsg(status_change,'^status=(-?[0-1])')
    IvyBindMsg(picture_change,'^newpic')
    IvyBindMsg(heartbeat,'^hb_syn')
    IvySendMsg('status?')
    IvyMainLoop()
Esempio n. 55
0
def save_configuration():
    print "Saving configuration to " + configfilename + "..."

    configfile = open(configfilename, "w")
    config.write(configfile)
    configfile.close()
def main():
    formatterStr = '%(asctime)s %(module)s:%(lineno)d [%(levelname)s]:%(message)s'
    logging.basicConfig(level=logging.DEBUG,
                        format=formatterStr)
    logger = logging.getLogger()

    config = configparser.RawConfigParser()

    config.add_section('Section1')
    config.set('Section1', 'an_int', '15')
    config.set('Section1', 'a_bool', 'true')
    config.set('Section1', 'a_float', '3.1415')
    config.set('Section1', 'baz', 'fun')
    config.set('Section1', 'bar', 'Python')
    config.set('Section1', 'foo', '%(bar)s is %(baz)s!')

    with io.open('example.cfg', 'w') as configfile:
        config.write(configfile)

    config1 = configparser.RawConfigParser()
    config1.read('example.cfg')

    logger.info("config1{")
    a_float = config1.getfloat('Section1', 'a_float')
    an_int = config1.getint('Section1', 'an_int')
    logger.info(a_float + an_int)

    if config1.getboolean('Section1', 'a_bool'):
        logger.info(config1.get('Section1', 'foo'))

    logger.info("}")

    logger.info("config2{")
    config2 = configparser.ConfigParser()
    config2.read('example.cfg')

    logger.info(config2.get('Section1', 'foo', 0))
    logger.info(config2.get('Section1', 'foo', 1))

    logger.info(config2.get('Section1', 'foo', 0, {'bar': 'Documentation',
                                                   'baz': 'evil'}))
    logger.info("}")
    logger.info("config3{")
    config3 = configparser.SafeConfigParser({'bar': 'Life', 'baz': 'hard'})
    config3.read('example.cfg')

    logger.info(config3.get('Section1', 'foo'))
    config3.remove_option('Section1', 'bar')
    config3.remove_option('Section1', 'baz')
    logger.info(config3.get('Section1', 'foo'))
    logger.info("}")

    logger.info("config4{")
    sample_config = """
    [mysqld]
    user = mysql
    pid-file = /var/run/mysqld/mysqld.pid
    skip-external-locking
    old_passwords = 1
    skip-bdb
    skip-innodb
    """
    config4 = configparser.RawConfigParser(allow_no_value=True)
    config4.readfp(io.BytesIO(sample_config))

    # Settings with values are treated as before:
    config4.get("mysqld", "user")

    # Settings without values provide None:
    config4.get("mysqld", "skip-bdb")

    # Settings which aren't specified still raise an error:
    config4.get("mysqld", "does-not-exist")
    logger.info("}")
Esempio n. 57
0
def write():
    f = open(configs_found[-1], "w")
    config.write(f)
    f.close()
Esempio n. 58
0
  def initLogging(cls, loggingLevel=None, console="stderr",
                  logToFile=False):
    """ A lower-level function to initialize python logging for the calling
    process. Supports logging output to a console (stderr or stdout) and/or log
    file.

    See also higher-level functions initTool() and initService().

    NOTE: by convention, logging should be initialized only by the main process.
        modules that provide APIs should not initialize logging as it would
        clobber the logging configuration desired by the application.

    :param loggingLevel: logging level string for filtering in root logger and
        output handlers; one of: "DEBUG", "INFO", "WARNING", "WARN", "ERROR",
        "CRITICAL" or "FATAL" that correspond to logging.DEBUG, logging.INFO,
        etc. Defaults to "INFO".

    :param console: Console logging destination; either "stderr" or "stdout";
        None to suppress output to console.

    :param logToFile: True to output logs to a file. If enalbed, a log file
        specific to the calling app instance will be created at file path
        generated by our getApplicationLogFilePath method.
    """
    validLoggingLevels = ["DEBUG", "INFO", "WARNING", "WARN", "ERROR",
                          "CRITICAL", "FATAL"]

    if loggingLevel is not None and loggingLevel not in validLoggingLevels:
      raise ValueError("loggingLevel %r not one of %s" %
                       (loggingLevel, validLoggingLevels))

    consoleHandlerArgsMap = dict(
      stderr="(sys.stderr, )",
      stdout="(sys.stdout, )"
    )

    if console is not None and console not in consoleHandlerArgsMap:
      raise ValueError("console %r not one of %s" %
                       (console, consoleHandlerArgsMap.keys()))

    # Configure logging timestamp for UTC
    logging.Formatter.converter = time.gmtime

    # Load the config tempalte
    config = ConfigParser()
    with open(cls.getLoggingConfTemplatePath(), 'r') as fileObj:
      config.readfp(fileObj)

    # Customize the config template

    handlers = []

    if console is not None:
      handlers.append("console")
      if loggingLevel is not None:
        config.set("handler_console", "level", loggingLevel)
      config.set("handler_console", "args", consoleHandlerArgsMap[console])

    if logToFile:
      handlers.append("file")

      # Get a log file path specific to the calling app
      logFilePath = cls.getApplicationLogFilePath()

      # Create the directory that will contain the log file
      makeDirectoryFromAbsolutePath(os.path.dirname(logFilePath))

      if loggingLevel is not None:
        config.set("handler_file", "level", loggingLevel)
      config.set("handler_file", "filename", logFilePath)

    if not handlers:
      print >> sys.stderr, (
        "WARNING: logging_support is disabling logging output because all "
        "output handlers are disabled")

      handlers.append("null")

    # Convert list of logging output handler names into comma-separated string
    handlers = ",".join(handlers)

    # Initialize the root logger
    if loggingLevel is not None:
      config.set("logger_root", "level", loggingLevel)
    config.set("logger_root", "handlers", handlers)

    # Initialize the list of all logging output handlers
    config.set("handlers", "keys", handlers)

    # Dump the customized config into a StringIO object for logging setup
    customConfigFile = StringIO()
    config.write(customConfigFile)
    customConfigFile.seek(0)

    # Initialize logging from StringIO file object
    logging.config.fileConfig(customConfigFile, disable_existing_loggers=False)
Esempio n. 59
0
def save_configuration():
    logger.info("Saving configuration to " + configfilename + "...")

    configfile = open(configfilename, "w")
    config.write(configfile)
    configfile.close()
Esempio n. 60
0
config = Config()
config.read(CONFIG_FILE)

DEBUG = config.get_boolean(APPLICATION_NAME, 'debug', False)
LOGIN_URL = config.get_option(APPLICATION_NAME, 'login_url', '/login/')
PORT = config.get_int(APPLICATION_NAME, 'port', 8000)

if config.has_option(APPLICATION_NAME, 'cookie_secret'):
    COOKIE_SECRET = config.get(APPLICATION_NAME, 'cookie_secret')
else:
    COOKIE_SECRET = base64.b64encode(uuid.uuid4().bytes + uuid.uuid4().bytes)
    if not config.has_section(APPLICATION_NAME):
        config.add_section(APPLICATION_NAME)
    config.set(APPLICATION_NAME, 'cookie_secret', COOKIE_SECRET)
    with open(CONFIG_FILE, 'wt') as cf:
        config.write(cf)

LOGGING_CONFIG = {
    'version': 1,
    'disable_existing_loggers': True,
    'formatters': {
        'verbose': {
            'format': '%(asctime)s - %(name)s - %(levelname)s - %(module)s - %(process)d - %(thread)d - %(message)s',
            'datefmt': '%d/%m/%Y %Hh%Mm%Ss'
        },
        'simple': {
            'format': '%(asctime)s - %(name)-12s - %(levelname)-8s - %(message)s',
            'datefmt': '%d/%m/%Y %Hh%Mm%Ss'
        }
    },
    'handlers': {