Java Code Examples for com.typesafe.config.ConfigFactory#load()

/** Loads the given config file from the local file system */
public Config parse(File file, Config... overrides) throws IOException {
  if (file == null || file.getPath().trim().length() == 0) {
    throw new MorphlineCompilationException("Missing morphlineFile parameter", null);
  }
  if (!file.exists()) {
    throw new FileNotFoundException("File not found: " + file);
  }
  if (!file.canRead()) {
    throw new IOException("Insufficient permissions to read file: " + file);
  }
  Config config = ConfigFactory.parseFile(file);
  for (Config override : overrides) {
    config = override.withFallback(config);
  }
  
  synchronized (LOCK) {
    ConfigFactory.invalidateCaches();
    config = ConfigFactory.load(config);
    config.checkValid(ConfigFactory.defaultReference()); // eagerly validate aspects of tree config
  }
  return config;
}
 

@Override
public Config get() {
    /*
     * 1. Service specific environment config (e. g. concierge-docker.conf)
     * 2. Service specific base config (e. g. concierge.conf)
     * 3. Common Ditto services config (ditto-service-base.conf)
     */
    final Config serviceSpecificEnvironmentConfig = getServiceSpecificEnvironmentConfig();

    final Config configWithFallbacks = serviceSpecificEnvironmentConfig
            .withFallback(getServiceSpecificBaseConfig())
            .withFallback(getCommonDittoServicesConfig())
            .resolve();

    return ConfigFactory.load(configWithFallbacks);
}
 

@Override
protected void configure()
{
    Config config = ConfigFactory.defaultApplication();
    Config referenceConfig = ConfigFactory.load(ConfigFactory.defaultReference());

    config = ConfigFactory.load(config).withFallback(referenceConfig);

    if (configURL != null) {
        config = ConfigFactory.load(ConfigFactory.parseURL(configURL)).withFallback(config);
    } else if (configFile != null) {
        config = fileConfig(configFile).withFallback(config);
    }

    this.bindConfig(config);

    install(new ApplicationModule(this.config));
}
 

@Before
public void setUp() throws Exception {
    Config config = ConfigFactory.load();
    Map<String, String> params = ConfigUtil.toMap(config);
    params.put(ClickhouseClusterSettings.CLICKHOUSE_USER, "");
    params.put(ClickhouseClusterSettings.CLICKHOUSE_PASSWORD, "");
    params.put(ClickhouseClusterSettings.CLICKHOUSE_HOSTS, "http://localhost:8123");

    ClickhouseSinkCommonParams commonParams = new ClickhouseSinkCommonParams(params);
    checker = new ClickhouseSinkScheduledChecker(commonParams);

    MockitoAnnotations.initMocks(this);
}
 

/**
 * Return the root configuration loaded from the helios configuration files.
 */
static Config loadConfig() {
  final ConfigResolveOptions resolveOptions = ConfigResolveOptions
      .defaults()
      .setAllowUnresolved(true);

  final ConfigParseOptions parseOptions = ConfigParseOptions.defaults();

  final Config baseConfig = ConfigFactory.load(BASE_CONFIG_FILE, parseOptions, resolveOptions);

  final Config appConfig = ConfigFactory.load(APP_CONFIG_FILE, parseOptions, resolveOptions);

  return appConfig.withFallback(baseConfig);
}
 

@Test
public void testToProducerConfig() {
    val config = ConfigFactory.load("producer.conf");
    val props = ConfigUtil.toProducerConfig(config);
    assertEquals(BOOTSTRAP_SERVERS, props.getProperty(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG));
    assertEquals(CLIENT_ID, props.getProperty(ProducerConfig.CLIENT_ID_CONFIG));
    assertEquals(KEY_SER, props.getProperty(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG));
    assertEquals(VALUE_SER, props.getProperty(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG));
}
 

public XTraceSettings() {
    Config config = ConfigFactory.load();
    on = config.getBoolean("xtrace.client.reporting.on");
    defaultEnabled = config.getBoolean("xtrace.client.reporting.default");
    discoveryMode = config.getBoolean("xtrace.client.reporting.discoverymode");
    traceMain = config.getBoolean("xtrace.client.tracemain");
    defaultLoggingLevel = XTraceLoggingLevel.valueOf(config.getString("xtrace.client.reporting.default_level").toUpperCase());
    mainMethodLoggingLevel = XTraceLoggingLevel.valueOf(config.getString("xtrace.client.tracemain_level").toUpperCase());
    classesEnabled = Sets.newHashSet(config.getStringList("xtrace.client.reporting.enabled"));
    classesDisabled = Sets.newHashSet(config.getStringList("xtrace.client.reporting.disabled"));
    recycleThreshold = config.getInt("xtrace.client.recycle-threshold");
}
 

@BeforeEach
void beforeEach() throws Exception {
  config = ConfigFactory.load("test.conf");
  server = new Server(config.getConfig("xrpc"));
  server.listenAndServe();
  endpoint = server.localEndpoint();
  h11client = OkHttpUnsafe.getUnsafeClient();
  h2client = OkHttpUnsafe.getUnsafeClient(Protocol.HTTP_2, Protocol.HTTP_1_1);
}
 

public static void main(String[] args) {

		final var config = ConfigFactory.load();
		/* START TRACING INSTRUMENTATION */
		final var sender = URLConnectionSender.newBuilder()
				.endpoint(config.getString("zipkin.endpoint")).build();
		final var reporter = AsyncReporter.builder(sender).build();
		final var tracing = Tracing.newBuilder().localServiceName("hello-consumer")
				.sampler(Sampler.ALWAYS_SAMPLE).spanReporter(reporter).build();
		final var kafkaTracing = KafkaTracing.newBuilder(tracing)
				.remoteServiceName("kafka").build();
		/* END TRACING INSTRUMENTATION */

		final var consumerConfigs = new Properties();
		consumerConfigs.setProperty(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,
				config.getString("kafka.bootstrap-servers"));
		consumerConfigs.setProperty(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG,
				StringDeserializer.class.getName());
		consumerConfigs.setProperty(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,
				StringDeserializer.class.getName());
		consumerConfigs.setProperty(ConsumerConfig.GROUP_ID_CONFIG, "hello-consumer");
		consumerConfigs.setProperty(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,
				OffsetResetStrategy.EARLIEST.name().toLowerCase());
		final var kafkaConsumer = new KafkaConsumer<String, String>(consumerConfigs);
		final var tracingConsumer = kafkaTracing.consumer(kafkaConsumer);

		tracingConsumer.subscribe(Collections.singletonList("hello"));

		while (!Thread.interrupted()) {
			var records = tracingConsumer.poll(Duration.ofMillis(Long.MAX_VALUE));
			for (var record : records) {
				brave.Span span = kafkaTracing.nextSpan(record).name("print-hello")
						.start();
				span.annotate("starting printing");
				out.println(String.format("Record: %s", record));
				span.annotate("printing finished");
				span.finish();
			}
		}
	}
 

protected Config createConfig() {
    final String testPath;
    try {
        testPath = testFolder.newFolder().getPath();
    } catch (IOException e) {
        throw new IllegalStateException("Could not create a directory for file binder", e);
    }
    final Properties properties = new Properties();
    properties.setProperty("mewbase.binders.files.store.basedir", Paths.get(testPath,"binders").toString() );
    properties.setProperty("mewbase.event.sink.file.basedir", Paths.get(testPath,"events").toString() );
    properties.setProperty("mewbase.event.source.file.basedir", Paths.get(testPath,"events").toString() );
    ConfigFactory.invalidateCaches();
    return ConfigFactory.load(ConfigFactory.parseProperties(properties));
}
 

@BeforeClass
public static void initTestFixture() {
    snapshotTestConf = ConfigFactory.load("tags-test");
}
 

public void reloadConfig() {
    ConfigFactory.invalidateCaches();
    Config config = ConfigFactory.load();
    configuration = new Configuration(config);
    loadConfig(configuration);
}
 

public Config loadBaseConfig() {
    log.info("Loading base configuration: appKey={}", appKey);
    val baseAppConfigs = ConfigFactory.load(BASE_APP_CONFIG_PATH);
    val defaultAppConfig = baseAppConfigs.getConfig(CK_KSTREAM_APP_DEFAULT_CONFIG);
    return baseAppConfigs.getConfig(appKey).withFallback(defaultAppConfig);
}
 

@BeforeClass
public static void initTestFixture() {
    streamingTestConfig = ConfigFactory.load("streaming-test");
}
 

@Deprecated
public LmdbBinderStore() { this(ConfigFactory.load()); }
 

@BeforeClass
public static void setUp() {
    gatewayHttpTestConfig = ConfigFactory.load("gateway-http-test");
}
 

private static Config readConfig() {
  Config config = ConfigFactory.load();
  config.checkValid(ConfigFactory.defaultReference(), CONFIG_ROOT);

  return config.getConfig(CONFIG_ROOT);
}
 

@BeforeClass
public static void initTestFixture() {
    indexInitializationTestConf = ConfigFactory.load("index-initialization-test");
}
 

/**
 * prepare config for later use.
 * @param envString environment string
 * @return config
 */
public static ParsecConfig load(String envString) {
    Config config = ConfigFactory.load(envString);
    return new TypeSafeConfWrapper(config);
}
 

public FileBinderStore() { this(ConfigFactory.load() ); }