Get all of the configuration files for the application.
199903
protected function getConfigurationFiles(ApplicationContract $app): array
    {
        $files = [];

        $configPath = $app->configPath();

        $configFiles = Finder::create()
            ->files()
            ->name('*.php')
            ->in($configPath);

        foreach ($configFiles as $file) {
            $directory = $this->getNestedDirectory($file, $configPath);
            $files[$directory.basename($file->getPathname(), '.php')] = $file->getPathname();
        }

        ksort($files, SORT_NATURAL);

        return $files;
    }
676778
def _all(self, *args, **kwargs):
        '''
        
        '''
        data = dict()
        data['software'] = self._software(**kwargs)
        data['system'] = self._system(**kwargs)
        data['services'] = self._services(**kwargs)
        try:
            data['configuration'] = self._configuration(**kwargs)
        except InspectorQueryException as ex:
            data['configuration'] = 'N/A'
            log.error(ex)
        data['payload'] = self._payload(**kwargs) or 'N/A'

        return data
656388
public static function configs()
    {
        $files = File::allFiles(base_path().'/plugins');
        $result = [];
        foreach ($files as $file){
            if($file->getBasename() == "config.json") {
                $result[] = json_decode(File::get($file->getPathname()));
            }
        }
        return $result;
    }
743802
private function getAllConfigNames()
    {
        if ($this->allConfig) {
            return $this->allConfig;
        }

        foreach ($this->configFactory->listAll() as $name) {
            $this->allConfig[] = $name;
        }

        return $this->allConfig;
    }
323923
def _load_configuration():
    """"""
    config = configparser.RawConfigParser()
    module_dir = os.path.dirname(sys.modules[__name__].__file__)
    if 'APPDATA' in os.environ:  # Windows
        os_config_path = os.environ['APPDATA']
    elif 'XDG_CONFIG_HOME' in os.environ:  # Modern Linux
        os_config_path = os.environ['XDG_CONFIG_HOME']
    elif 'HOME' in os.environ:  # Legacy Linux
        os_config_path = os.path.join(os.environ['HOME'], '.config')
    else:
        os_config_path = None
    locations = [os.path.join(module_dir, 'praw.ini'), 'praw.ini']
    if os_config_path is not None:
        locations.insert(1, os.path.join(os_config_path, 'praw.ini'))
    if not config.read(locations):
        raise Exception('Could not find config file in any of: {0}'
                        .format(locations))
    return config
123361
def get_settings():
    '''
    
    '''
    settings = {}
    for config_file in config_files():
        config_contents = load_config(config_file)
        if config_contents is not None:
            settings = deep_merge(settings, config_contents)
    return settings
428700
def _get_config_files():
    
    # default files
    conf_files = cfg.find_config_files(project='monasca',
                                       prog='monasca-persister')
    # deprecated config files (only used if standard config files are not there)
    if len(conf_files) == 0:
        old_conf_files = cfg.find_config_files(project='monasca',
                                               prog='persister')
        if len(old_conf_files) > 0:
            LOG.warning('Found deprecated old location "{}" '
                        'of main configuration file'.format(old_conf_files))
            conf_files += old_conf_files
    return conf_files
996158
def config(self):
        """"""

        return self._h._get_resource(
            resource=('apps', self.name, 'config_vars'),
            obj=ConfigVars, app=self
        )
634001
def files(self):
    """"""
    all_files = set()
    for label in self.filesets:
      all_files.update(self.filesets[label])
    return all_files
991257
function () {
    var appConfigPath = this.root.join('config', 'application'),
        envConfigPath = this.root.join('config', 'environment', this.env + '.js'),
        config, appConfig, envConfig;

    debug('configuring');

    // require the config object, given as the argument to exported `configure`
    // functions in application/environment config files
    config = require(this._root.join('lib', 'config'))(this);

    // only load application config if we're in an app
    if (this.inApp) {
      // application.js configuration
      appConfig = require(appConfigPath)(config);

      // environmental override configs are optional
      if (fs.existsSync(envConfigPath)) {
        // environment config overrides eg development.js
        // should export a function that takes the config object as an arg
        envConfig = require(envConfigPath)(config);
      }
    }

    this.config = config;

    return config;
  }
967205
private List<Resource> getConfigurations() {
		List<Resource> result = new ArrayList<Resource>();
		for (String delimitedConfigurationUrl : configurationUrls) {
			String[] tokens = StringUtils.commaDelimitedListToStringArray(delimitedConfigurationUrl);
			tokens = StringUtils.trimArrayElements(tokens);
			for (String configurationUrl : tokens) {
				configurationUrl = configurationUrl.trim();
				Resource configuration = resourceLoader.getResource(configurationUrl);
				if (configuration != null && configuration.exists()) {
					result.add(configuration);
				} else if (ignoreConfigurationNotFound) {
					logger.debug("Ignore missing configuration file {}", configuration);
				} else {
					throw new EmbeddedJmxTransException("Configuration file " + configuration + " not found");
				}
			}
		}
		return result;
	}
1310558
def build_config(config_file=get_system_config_directory()):
    
    config = Config(config_file, allow_no_value=True)
    application_versions = find_applications_on_system()

    # Add found versions to config if they don't exist. Versions found
    # in the config file takes precedence over versions found in PATH.
    for item in application_versions.iteritems():
        if not config.has_option(Config.EXECUTABLES, item[0]):
            config.set(Config.EXECUTABLES, item[0], item[1])
    return config
567604
def find_config_file(self, project=None, extension='.conf'):
        
        cfg_dirs = self._get_config_dirs()
        config_files = self._search_dirs(cfg_dirs, project, extension)

        return config_files
124261
def load_all(self):
        '''
        
        '''
        # check for custom conf file before loading conf
        self._load_command_line(conf_only=True)
        self._load_config_file()
        self._load_env()
        self._load_command_line()
        self._imply_options()
        self._validate_options()
        return self
1304685
def available_configuration_files(self):
        """"""
        known_files = [GLOBAL_CONFIG, LOCAL_CONFIG, self.environment.get('PIP_ACCEL_CONFIG')]
        absolute_paths = [parse_path(pathname) for pathname in known_files if pathname]
        return [pathname for pathname in absolute_paths if os.path.isfile(pathname)]
878659
public static function getConfigFiles()
    {
        $configFiles = array();
        $symfonyConfigDir =
            self::getRootDir().'app'.DIRECTORY_SEPARATOR.
            'config';
        $campaignchainConfigDir =
            self::getRootDir().'app'.DIRECTORY_SEPARATOR.
            'campaignchain'.DIRECTORY_SEPARATOR.
            'config';

        $configFiles['kernel_symfony'] =
            self::getRootDir().'app'.DIRECTORY_SEPARATOR.'AppKernel.php';
        
        $configFiles['bundles_dist'] = self::getRootDir().'app'.DIRECTORY_SEPARATOR.
            'AppKernel_campaignchain.php';
        $configFiles['bundles'] = self::getRootDir().'app'.DIRECTORY_SEPARATOR.
            'campaignchain'.DIRECTORY_SEPARATOR.
            'AppKernel.php';
        
        $configFiles['config_dist'] = $symfonyConfigDir.DIRECTORY_SEPARATOR.
            'config_campaignchain_imports.yml.dist';
        $configFiles['config'] = $campaignchainConfigDir.DIRECTORY_SEPARATOR.
            'imports.yml';
        
        $configFiles['routing_dist'] = $symfonyConfigDir.DIRECTORY_SEPARATOR.
            'routing_campaignchain.yml.dist';
        $configFiles['routing'] = $campaignchainConfigDir.DIRECTORY_SEPARATOR.
            'routing.yml';
        
        $configFiles['security_dist'] = $symfonyConfigDir.DIRECTORY_SEPARATOR.
            'security_campaignchain.yml.dist';
        $configFiles['security'] = $campaignchainConfigDir.DIRECTORY_SEPARATOR.
            'security.yml';

        return $configFiles;
    }
326925
function loadAppConfigs() {
        var appConfigs = {};
        var appDir = path.join(this.injector.rootDir, '/app');

        if (!fs.existsSync(appDir)) {
            return appConfigs;
        }

        var me = this;
        var appNames = fs.readdirSync(appDir);

        _.each(appNames, function (appName) {
            appConfigs[appName] = me.injector.loadModule('app/' + appName + '/' + appName + '.app');
        });

        return appConfigs;
    }