com.netflix.archaius.guice.ArchaiusModule Java Examples

public EmbeddedTitusFederation boot() {
    logger.info("Starting Titus Federation");

    injector = InjectorBuilder.fromModules(
            new EmbeddedJettyModule(httpPort),
            new ArchaiusModule() {
                @Override
                protected void configureArchaius() {
                    // We can set some properties only after the gateway is started.ł
                    config.setProperty("titus.federation.cells", buildCellString());

                    bindApplicationConfigurationOverride().toInstance(config);
                }
            },
            new TitusFederationModule()
    ).createInjector();
    return this;
}
 

@Test
public void testMultipleInstancesOfHealthModuleInstalled() throws InterruptedException, ExecutionException {
    LifecycleInjector injector = InjectorBuilder.fromModules(new HealthModule() {
        @Override
        protected void configureHealth() {
            bindAdditionalHealthIndicator().toInstance(healthy);
        }
    }, new HealthModule() {
        @Override
        protected void configureHealth() {
            bindAdditionalHealthIndicator().toInstance(unhealthy);
        }
    }, new ArchaiusModule()).createInjector();
    HealthCheckAggregator aggregator = injector.getInstance(HealthCheckAggregator.class);
    assertNotNull(aggregator);
    HealthCheckStatus healthCheckStatus = aggregator.check().get();
    assertFalse(healthCheckStatus.isHealthy());
    assertEquals(2, healthCheckStatus.getHealthResults().size());
}
 

@Override
protected void configure() {
    install(new ArchaiusModule());
    bind(Registry.class).toInstance(new DefaultRegistry());

    install(new SimulatedCloudEndpointModule());
    install(new EmbeddedJerseyModule());
    bind(SimulatedCloud.class).asEagerSingleton();
}
 

public static void main(String[] args) throws Exception {
    InjectorBuilder.fromModules(
            new TitusFederationModule(),
            new Archaius2JettyModule(),
            new ArchaiusModule() {
                @Override
                protected void configureArchaius() {
                    bindApplicationConfigurationOverrideResource("laptop");
                }
            })
            .createInjector()
            .awaitTermination();
}
 

@Override
protected void configure() {
    install(new CoreModule());
    install(new ValidationModule());
    install(new ArchaiusModule());
    install(new HealthModule());
    install(new JettyModule());
    install(new GRPCModule());

    bindInterceptor(Matchers.any(), Matchers.annotatedWith(Service.class), new ServiceInterceptor(getProvider(Validator.class)));
    bind(Configuration.class).to(SystemPropertiesDynomiteConfiguration.class);
    bind(ExecutorService.class).toProvider(ExecutorServiceProvider.class).in(Scopes.SINGLETON);
    bind(WorkflowSweeper.class).asEagerSingleton();
    bind(WorkflowMonitor.class).asEagerSingleton();
}
 

@Test
public void testNoIndicators() throws InterruptedException, ExecutionException {
    LifecycleInjector injector = InjectorBuilder.fromModules(new HealthModule(), new ArchaiusModule()).createInjector();
    HealthCheckAggregator aggregator = injector.getInstance(HealthCheckAggregator.class);
    assertNotNull(aggregator);
    HealthCheckStatus healthCheckStatus = aggregator.check().get();
    assertTrue(healthCheckStatus.isHealthy());
    assertEquals(0, healthCheckStatus.getHealthResults().size());
}
 

@Test
public void testConfiguringIndicatorsByExtendingHealthModule() throws InterruptedException, ExecutionException {
    LifecycleInjector injector = InjectorBuilder.fromModules(new HealthModule() {
        @Override
        protected void configureHealth() {
            bindAdditionalHealthIndicator().toInstance(healthy);
        }
    }, new ArchaiusModule()).createInjector();
    HealthCheckAggregator aggregator = injector.getInstance(HealthCheckAggregator.class);
    assertNotNull(aggregator);
    HealthCheckStatus healthCheckStatus = aggregator.check().get();
    assertTrue(healthCheckStatus.isHealthy());
    assertEquals(1, healthCheckStatus.getHealthResults().size());
}
 

@BeforeSuite
public void setupEnv() {
    Properties props = getProps();

    try {

        LifecycleInjectorBuilder builder = LifecycleInjector.builder();
        builder.withModules(
                new EurekaClientModule(),
                new EVCacheModule(),
                new DIConnectionModule(),
                new SpectatorModule(),
                new ArchaiusModule() {
                	protected void configureArchaius() {
                		bindApplicationConfigurationOverride().toInstance(MapConfig.from(props));
                	};
                }
                );

        injector = builder.build().createInjector();
        lifecycleManager = injector.getInstance(LifecycleManager.class);

        lifecycleManager.start();
        injector.getInstance(ApplicationInfoManager.class);
        final EVCacheModule lib = injector.getInstance(EVCacheModule.class);
        manager = injector.getInstance(EVCacheClientPoolManager.class);
    } catch (Throwable e) {
        e.printStackTrace();
        log.error(e.getMessage(), e);
    }

}
 

public EmbeddedTitusGateway boot() {
    Stopwatch timer = Stopwatch.createStarted();
    logger.info("Starting Titus Gateway");

    injector = InjectorBuilder.fromModules(
            newJettyModule(),
            new ArchaiusModule() {
                @Override
                protected void configureArchaius() {
                    config.setProperty("titus.masterClient.masterIp", masterGrpcHost);

                    if (embeddedTitusMaster == null) {
                        config.setProperty("titus.masterClient.masterGrpcPort", masterGrpcPort);
                        config.setProperty("titus.masterClient.masterHttpPort", masterHttpPort);
                    } else {
                        // In the embedded mode, master cannot run jetty, so we set only GRPC port.
                        config.setProperty("titus.masterClient.masterGrpcPort", embeddedTitusMaster.getGrpcPort());
                        config.setProperty("titus.masterClient.masterHttpPort", "0");
                    }

                    bindApplicationConfigurationOverride().toInstance(config);
                }
            },
            Modules.override(new TitusGatewayModule(enableREST, false)).with(new AbstractModule() {
                @Override
                protected void configure() {
                    if (store != null) {
                        bind(JobStore.class).toInstance(store);
                    }

                    bind(new TypeLiteral<AdmissionValidator<JobDescriptor>>() {
                    }).toInstance(validator);
                }

                @Provides
                @Singleton
                public AdmissionSanitizer<JobDescriptor> getJobSanitizer(TitusValidatorConfiguration configuration) {
                    return new AggregatingSanitizer(configuration, Collections.singletonList(jobSanitizer));
                }
            })
    ).createInjector();

    logger.info("Embedded TitusGateway started in {}ms", timer.elapsed(TimeUnit.MILLISECONDS));

    return this;
}
 

@Before
public void init() {
    injector = InjectorBuilder.fromModules(new ArchaiusModule(), new ArchaiusHealthStatusFilterModule()).createInjector();
    config = injector.getInstance(Key.get(SettableConfig.class, RuntimeLayer.class));
    matcher = injector.getInstance(IndicatorMatcher.class);
}