Refine search
private ConfigurationSource getConfigurationSource(URL url) throws IOException { InputStream stream = url.openStream(); if (FILE_PROTOCOL.equals(url.getProtocol())) { return new ConfigurationSource(stream, ResourceUtils.getFile(url)); } return new ConfigurationSource(stream, url); }
@Override public String getConfigurationInfo() { return getConfiguration().getConfigurationSource().toString(); }
String finalConfPath = absolutePath.toString(); LOGGER.info("final conf path: {}", finalConfPath); if (logConfFile.exists() && logConfFile.isFile()) { try (FileInputStream logFis = new FileInputStream(logConfFile)) { ConfigurationSource configurationSource = new ConfigurationSource(logFis, logConfFile); Configurator.initialize(null, configurationSource); LOGGER.info("using log conf file: {}", logPropertiesPath); } catch (Exception e) { LOGGER.warn("failed to set log conf file at {}. using default conf", logPropertiesPath);
public JsonConfiguration(final LoggerContext loggerContext, final ConfigurationSource configSource) { super(loggerContext, configSource); final File configFile = configSource.getFile(); byte[] buffer; try { try (final InputStream configStream = configSource.getInputStream()) { buffer = toByteArray(configStream); setName(configSource.getLocation()); LOGGER.error("Error parsing " + configSource.getLocation(), ex);
@Override public Configuration getConfiguration(final LoggerContext loggerContext, final ConfigurationSource source) { if (source != null) { final String config = source.getLocation(); for (final ConfigurationFactory factory : getFactories()) { final String[] types = factory.getSupportedTypes(); if (types != null) { for (final String type : types) { if (type.equals(ALL_TYPES) || config != null && config.endsWith(type)) { final Configuration c = factory.getConfiguration(loggerContext, source); if (c != null) { LOGGER.debug("Loaded configuration from {}", source); return c; } LOGGER.error("Cannot determine the ConfigurationFactory to use for {}", config); return null; } } } } } LOGGER.error("Cannot process configuration, input source is null"); return null; } }
if (configFile != null && configFile.exists() && configFile.canRead()) { try { return new ConfigurationSource(new FileInputStream(configFile), configFile); } catch (final FileNotFoundException ex) { ConfigurationFactory.LOGGER.error("Cannot locate file {}", configLocation.getPath(), ex); final ClassLoader loader = LoaderUtil.getThreadContextClassLoader(); final String path = ConfigurationFactory.extractClassLoaderUriPath(configLocation); final ConfigurationSource source = fromResource(path, loader); if (source != null) { return source; ConfigurationFactory.LOGGER.error("File not found in file system or classpath: {}", configLocation.toString()); return null; return new ConfigurationSource(configLocation.toURL().openStream(), configLocation.toURL()); } catch (final MalformedURLException ex) { ConfigurationFactory.LOGGER.error("Invalid URL {}", configLocation.toString(), ex); } catch (final Exception ex) { ConfigurationFactory.LOGGER.error("Unable to access {}", configLocation.toString(), ex);
protected void initLog(Config config) throws IOException { File logFile = config.getLogConfigurationFile(); Preconditions.checkState(logFile.exists(), "Log config file %s does not exist.", logFile); log.debug(String.format("%s Loading log configuration from %s", ApplicationBoot.BOOT_LOG_PREFIX, logFile)); List<String> configLines = Files.readAllLines(logFile.toPath(), StandardCharsets.UTF_8); List<String> finalLogConfigurationProperties = ApplicationConfiguration.loadProperties(configLines, config.get()); StringBuilder finalConfiguration = new StringBuilder(); for (String finalLogConfigurationProperty : finalLogConfigurationProperties) { finalConfiguration.append(finalLogConfigurationProperty).append("\n"); } try (ByteArrayInputStream inputStream = new ByteArrayInputStream(finalConfiguration.toString().getBytes(StandardCharsets.UTF_8))) { Configurator.initialize(null, new ConfigurationSource(inputStream)); } log = LogManager.getLogger(getClass()); log.debug(String.format("%s Final log configuration done with file %s", ApplicationBoot.BOOT_LOG_PREFIX, logFile)); }
public void createAdvertiser(final String advertiserString, final ConfigurationSource configSource) { byte[] buffer = null; try { if (configSource != null) { final InputStream is = configSource.getInputStream(); if (is != null) { buffer = toByteArray(is); } } } catch (final IOException ioe) { LOGGER.warn("Unable to read configuration source " + configSource.toString()); } super.createAdvertiser(advertiserString, configSource, buffer, contentType); }
/** * Loads the configuration from the location represented by the String. * @param config The configuration location. * @param loader The default ClassLoader to use. * @return The InputSource to use to read the configuration. */ protected ConfigurationSource getInputFromString(final String config, final ClassLoader loader) { try { final URL url = new URL(config); return new ConfigurationSource(url.openStream(), FileUtils.fileFromUri(url.toURI())); } catch (final Exception ex) { final ConfigurationSource source = ConfigurationSource.fromResource(config, loader); if (source == null) { try { final File file = new File(config); return new ConfigurationSource(new FileInputStream(file), file); } catch (final FileNotFoundException fnfe) { // Ignore the exception LOGGER.catching(Level.DEBUG, fnfe); } } return source; } }
is = url.openStream(); } catch (final IOException ioe) { ConfigurationFactory.LOGGER.catching(Level.DEBUG, ioe); return null; return new ConfigurationSource(is, FileUtils.fileFromUri(url.toURI())); } catch (final URISyntaxException ex) { ConfigurationFactory.LOGGER.catching(Level.DEBUG, ex); return new ConfigurationSource(is, url);
@Override public PropertiesConfiguration getConfiguration(final LoggerContext loggerContext, final ConfigurationSource source) { final Properties properties = new Properties(); try (InputStream configStream = source.getInputStream()) { properties.load(configStream); } catch (final IOException ioe) { throw new ConfigurationException("Unable to load " + source.toString(), ioe); locationsWithDeprecatedPatterns.add(source.getLocation()); properties.setProperty(name, value.replace("%marker", "[%node_name]%marker "));
ConfigurationSource source = new ConfigurationSource(); source.setLocation(logConfigurationFile); source.setFile(new File(logConfigurationFile)); source.setInputStream(new FileInputStream(logConfigurationFile)); Configurator.initialize(null, source);
private Configuration getConfiguration(final LoggerContext loggerContext, final String configLocationStr) { ConfigurationSource source = null; try { source = ConfigurationSource.fromUri(NetUtils.toURI(configLocationStr)); } catch (final Exception ex) { // Ignore the error and try as a String. LOGGER.catching(Level.DEBUG, ex); } if (source == null) { final ClassLoader loader = LoaderUtil.getThreadContextClassLoader(); source = getInputFromString(configLocationStr, loader); } if (source != null) { for (final ConfigurationFactory factory : getFactories()) { final String[] types = factory.getSupportedTypes(); if (types != null) { for (final String type : types) { if (type.equals(ALL_TYPES) || configLocationStr.endsWith(type)) { final Configuration config = factory.getConfiguration(loggerContext, source); if (config != null) { return config; } } } } } } return null; }
@Override public PropertiesConfiguration getConfiguration(final LoggerContext loggerContext, final ConfigurationSource source) { final Properties properties = new Properties(); try (final InputStream configStream = source.getInputStream()) { properties.load(configStream); } catch (final IOException ioe) { throw new ConfigurationException("Unable to load " + source.toString(), ioe); } return new PropertiesConfigurationBuilder() .setConfigurationSource(source) .setRootProperties(properties) .setLoggerContext(loggerContext) .build(); } }
private InputStream openInputStream(final String filePathOrUri) { return ConfigurationSource.fromUri(NetUtils.toURI(filePathOrUri)).getInputStream(); }
@Override public String getConfigText(final String charsetName) throws IOException { try { final ConfigurationSource source = loggerContext.getConfiguration().getConfigurationSource(); final ConfigurationSource copy = source.resetInputStream(); final Charset charset = Charset.forName(charsetName); return readContents(copy.getInputStream(), charset); } catch (final Exception ex) { final StringWriter sw = new StringWriter(BUFFER_SIZE); ex.printStackTrace(new PrintWriter(sw)); return sw.toString(); } }
public static String getConfigurationSourceLocation(final Configuration config) { return config.getConfigurationSource().getLocation(); }
@Override public Configuration getConfiguration(final LoggerContext loggerContext, final ConfigurationSource source) { final ConfigurationBuilder<BuiltConfiguration> builder; try (final InputStream configStream = source.getInputStream()) { builder = new Log4j1ConfigurationParser().buildConfigurationBuilder(configStream); } catch (final IOException e) { throw new ConfigurationException("Unable to load " + source, e); } return builder.build(); }
/** * Creates a {@link Configuration} initialized with given log4j configuration file without making this * configuration active. * * @param log4jConfigurationFile the XML configuration file to load * @return {@link Configuration} initialized with log4jConfigurationFile * @since 10.3 */ public static Configuration newConfiguration(File log4jConfigurationFile) { if (log4jConfigurationFile == null || !log4jConfigurationFile.exists()) { throw new IllegalArgumentException("Missing Log4J configuration: " + log4jConfigurationFile); } else { XmlConfiguration configuration = new XmlConfiguration(null, ConfigurationSource.fromUri(log4jConfigurationFile.toURI())); configuration.initialize(); log.debug("Log4j configuration " + log4jConfigurationFile + " successfully loaded."); return configuration; } }
try { ConfigurationSource configurationSource = new ConfigurationSource(new FileInputStream(logConfFile), logConfFile); Configurator.initialize(null, configurationSource); LOGGER.info("using log conf file: {}", logPropertiesPath); } catch (Exception e) { LOGGER.warn("failed to set log conf file at {}. using default conf", logPropertiesPath); LOGGER.error(e); throw e;