def filepath_constructor(loader, node): path = loader.construct_python_str(node) fp = filepath.FilePath(util.expand_filepath(path)) # add a marker to dump the configuration fp.origpath = path return fp
def pipedpath_constructor(loader, node): path = loader.construct_python_str(node) original_path = path package = piped # the path may be an empty string, which should be the root piped package path. if path: paths = path.split(os.path.sep) for i in range(1, len(paths)+1): package_name = '.'.join(['piped'] + paths[:i]) try: any = reflect.namedAny(package_name) except (AttributeError, reflect.ObjectNotFound) as e: # AttributeErrors may occur if we look a file that has the # same prefix as an existing module or package break # we don't want to start looking into modules: if not is_package(any): break package = any # update the remaining path path = os.path.sep.join(paths[i:]) root = filepath.FilePath(package.__file__).parent() fp = root.preauthChild(util.expand_filepath(path)) # add markers for dumping the configuration fp.origpath = original_path fp.pipedpath = True return fp
def __init__( self, path, defaultType="text/html", ignoredExts=(), registry=None, allowExt=0, namespace=None, preprocessors=None, **kwargs ): static.File.__init__( self, util.expand_filepath(path), defaultType=defaultType, ignoredExts=ignoredExts, registry=registry, allowExt=allowExt, **kwargs ) self.namespace = dict(self=self) self.namespace.update(namespace or dict()) self.preprocessor_definitions = preprocessors or dict() self.preprocessors = list() for lambda_definition in self.preprocessor_definitions.values(): func = util.create_lambda_function(lambda_definition, **self.namespace) self.preprocessors.append(func)
def load_from_file(self, filename): """ Load the configuration by parsing the data in the given file. For an overview of how configuration is loaded, see :doc:`/topic/configuration` """ filename = util.expand_filepath(filename) log.debug('Loading configuration from: %s'%filename) self._fail_if_configuration_file_does_not_exist(filename) base_config = yaml.load(open(filename)) complete_config = self._load_config(base_config, [filename]) self._resolve_aliases(complete_config) self._config = complete_config log.debug('Loaded configuration: '+pformat(complete_config))
def _load_includes(self, current_config, include_paths, visited_files): """ Recursively handles includes of other configuration-files. """ for include_path_or_filepath in include_paths: include_path = util.expand_filepath(include_path_or_filepath) if include_path in visited_files: _warn_because_file_is_loaded_multiple_times(include_path, visited_files) visited_files.append(include_path) self._fail_if_configuration_file_does_not_exist(include_path) try: included_config = yaml.load(open(include_path)) included_config = self._load_config(included_config, visited_files) current_config = util.merge_dicts(included_config, current_config, replace_primitives=True) except exceptions.ConfigurationError: raise except Exception, why: raise exceptions.ConfigurationError('Error in configuration file %s: %s'%(include_path, why))
def __init__(self, provider, process_name, executable, restart=False, restart_wait=1, args=None, path=None, stdout=None, stderr=None, stdin=None): self.process_name = process_name self.executable = executable self.restart = restart self.restart_wait = restart_wait self.args = args or list() self.path = None if path: self.path = util.expand_filepath(path) stdout_config = stdout or dict() stdout_protocol_name = stdout_config.pop('protocol', self.default_output_protocol_name) stderr_config = stderr or dict() stderr_protocol_name = stderr_config.pop('protocol', self.default_output_protocol_name) stdin_config = stdin or dict() stdin_protocol_name = stdin_config.pop('protocol', self.default_input_protocol_name) self.stdout_protocol = IProcessOutputProtocol(reflect.namedAny(stdout_protocol_name)(self, 'stdout', **stdout_config)) self.stderr_protocol = IProcessOutputProtocol(reflect.namedAny(stderr_protocol_name)(self, 'stderr', **stderr_config)) self.stdin_protocol = IProcessInputProtocol(reflect.namedAny(stdin_protocol_name)(self, **stdin_config))
def _get_filepath_for_persisted_context(self, context_name): kind = self.persisted_contexts[context_name].get('kind', 'json') file = self.persisted_contexts[context_name].get('file', '%s.%s' % (context_name, kind)) return util.ensure_filepath(util.expand_filepath(file))
def _get_concatenated_lines(self): buf = list() for fp in self.file_paths: file = open(util.expand_filepath(fp)) buf.extend(file.readlines()) return buf