com.netflix.governator.lifecycle.LifecycleManager Java Examples

@Override
public void init() {
	// TODO:  this really feels like it should be part of bootstrap, but if that is done
	// then @WarmUp, @PostConstruct cannot use the ServiceLocator
	try {
	   LifecycleManager manager = getInstance(LifecycleManager.class);
      if(manager != null) {
         LOGGER.info("Starting up all modules...");
         try {
            manager.start();
            LOGGER.info("Started up");
         } catch(Exception e) {
            LOGGER.error("Failure to startup the injection context", e);
            throw new RuntimeException("Failure to startup the injection context", e);
         }
      }
   } catch (Exception ex) {
      // ignore
   }
}
 

public void start() {
    try {
        logger.info("Starting apollo..");

        injector = LifecycleInjector.builder().withModules(
                new ApolloModule(configurationProvider.get()),
                new ApolloMyBatisModule(configurationProvider.get().getDatabase())
        ).build().createInjector();

        lifecycleManager = injector.getInstance(LifecycleManager.class);
        lifecycleManager.start();

        logger.info("Apollo started");
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}
 

@Override
protected Injector getInjector() {
    List<Module> moduleList = new ArrayList<>();
    moduleList.add(new JaxServletModule());
    moduleList.add(new RaigadGuiceModule());
    Injector injector;

    try {
        injector = LifecycleInjector.builder().withModules(moduleList).build().createInjector();
        startJobs(injector);

        LifecycleManager manager = injector.getInstance(LifecycleManager.class);
        manager.start();
    }
    catch (Exception e) {
        logger.error(e.getMessage(),e);
        throw new RuntimeException(e.getMessage(), e);
    }

    return injector;
}
 

private Injector createInjector(final Properties properties) {
    injector = LifecycleInjector
            .builder()
            .withBootstrapModule(
                new BootstrapModule() {
                    @Override
                    public void configure(BootstrapBinder binder) {
                        binder.bindConfigurationProvider().toInstance(
                                new PropertiesConfigurationProvider(properties));
                    }
                }
            )
            .withModules(new SuroClientModule())
            .build().createInjector();
    LifecycleManager manager = injector.getInstance(LifecycleManager.class);

    try {
        manager.start();
    } catch (Exception e) {
        throw new RuntimeException("LifecycleManager cannot start with an exception: " + e.getMessage(), e);
    }
    return injector;
}
 

@Before
public void setup() throws Exception {
    servers = TestConnectionPool.startServers(3);

    final Properties props = new Properties();
    props.setProperty(ClientConfig.LB_SERVER, TestConnectionPool.createConnectionString(servers));
    props.setProperty(ClientConfig.MINIMUM_RECONNECT_TIME_INTERVAL, "1");
    props.setProperty(ClientConfig.RECONNECT_INTERVAL, "1");
    props.setProperty(ClientConfig.RECONNECT_TIME_INTERVAL, "1");
    props.setProperty(ClientConfig.APP, "app");

    injector = LifecycleInjector.builder()
            .withBootstrapModule(new BootstrapModule() {
                @Override
                public void configure(BootstrapBinder binder) {
                    binder.bindConfigurationProvider().toInstance(new PropertiesConfigurationProvider(props));
                    binder.bind(ILoadBalancer.class).to(StaticLoadBalancer.class);
                }
            }).build().createInjector();
    injector.getInstance(LifecycleManager.class).start();
}
 

@Override
protected void before() throws Exception {
    statusPort = TestUtils.pickPort();
    serverPort = TestUtils.pickPort();

    Properties props = new Properties();
    props.put("SuroServer.statusServerPort", Integer.toString(statusPort));
    props.put("SuroServer.port", Integer.toString(serverPort));
    props.put(DynamicPropertySinkConfigurator.SINK_PROPERTY, sinkDesc);
    props.put(DynamicPropertyInputConfigurator.INPUT_CONFIG_PROPERTY, inputConfig);
    if (mapDesc != null) {
        props.put(DynamicPropertyRoutingMapConfigurator.ROUTING_MAP_PROPERTY, mapDesc);
    }

    SuroServer.create(injector, props, new SuroPlugin() {
        @Override
        protected void configure() {
            this.addSinkType("TestSink", TestMessageRouter.TestMessageRouterSink.class);
        }
    });
    injector.get().getInstance(LifecycleManager.class).start();
    injector.get().getInstance(StatusServer.class).waitUntilStarted();
}
 

@Before
public void setup() throws Exception {
    servers = TestConnectionPool.startServers(3);

    final Properties props = new Properties();
    props.setProperty(ClientConfig.LB_SERVER, TestConnectionPool.createConnectionString(servers));
    props.setProperty(ClientConfig.MINIMUM_RECONNECT_TIME_INTERVAL, "1");
    props.setProperty(ClientConfig.RECONNECT_INTERVAL, "1");
    props.setProperty(ClientConfig.RECONNECT_TIME_INTERVAL, "1");
    props.setProperty(ClientConfig.APP, "app");

    injector = LifecycleInjector.builder()
            .withBootstrapModule(new BootstrapModule() {
                @Override
                public void configure(BootstrapBinder binder) {
                    binder.bindConfigurationProvider().toInstance(new PropertiesConfigurationProvider(props));
                    binder.bind(ILoadBalancer.class).to(StaticLoadBalancer.class);
                }
            }).build().createInjector();
    injector.getInstance(LifecycleManager.class).start();
}
 

public void setup() throws Exception {
    servers = TestConnectionPool.startServers(1);

    props.put(ClientConfig.LB_SERVER, TestConnectionPool.createConnectionString(servers));
    props.put(ClientConfig.CONNECTION_TIMEOUT, Integer.toString(Integer.MAX_VALUE));

    injector = LifecycleInjector.builder()
            .withBootstrapModule(new BootstrapModule() {
                @Override
                public void configure(BootstrapBinder binder) {
                    binder.bindConfigurationProvider().toInstance(new PropertiesConfigurationProvider(props));
                }
            })
            .withAdditionalModules(new AbstractModule() {
                @Override
                protected void configure() {
                    bind(ILoadBalancer.class).to(StaticLoadBalancer.class);
                }
            })
            .build().createInjector();
    injector.getInstance(LifecycleManager.class).start();

    pool = injector.getInstance(ConnectionPool.class);
    assertEquals(pool.getPoolSize(), 1);
}
 

private void setupFile(final Properties props, String filePath) throws Exception {
    servers = TestConnectionPool.startServers(3);

    props.put(ClientConfig.LB_SERVER, TestConnectionPool.createConnectionString(servers));

    props.put(ClientConfig.ASYNC_FILEQUEUE_PATH, filePath);
    props.put(ClientConfig.ASYNC_QUEUE_TYPE, "file");

    injector = LifecycleInjector.builder()
            .withBootstrapModule(new BootstrapModule() {
                @Override
                public void configure(BootstrapBinder binder) {
                    binder.bindConfigurationProvider().toInstance(new PropertiesConfigurationProvider(props));
                    binder.bind(ILoadBalancer.class).to(StaticLoadBalancer.class);
                }
            }).build().createInjector();
    injector.getInstance(LifecycleManager.class).start();
}
 

@Test
public void test() throws Exception {
    AtomicReference<Injector> injector = new AtomicReference<Injector>();
    Properties properties = new Properties();
    properties.setProperty(DynamicPropertyRoutingMapConfigurator.ROUTING_MAP_PROPERTY, "{}");
    properties.setProperty(DynamicPropertySinkConfigurator.SINK_PROPERTY,
            "{\n" +
                    "    \"default\": {\n" +
                    "        \"type\": \"testsuroservice\"\n" +
                    "        }\n" +
                    "    }\n" +
                    "}");
    properties.setProperty(DynamicPropertyInputConfigurator.INPUT_CONFIG_PROPERTY,
            "[\n" +
                    "    {\n" +
                    "        \"type\": \"testsuroservice\"\n" +
                    "    }\n" +
                    "]");
    SuroServer.create(injector, properties, new SuroPlugin() {
        @Override
        protected void configure() {
            addInputType("testsuroservice", TestSuroServiceInput.class);
            addSinkType("testsuroservice", TestSuroServiceSink.class);
        }
    });

    injector.get().getInstance(LifecycleManager.class).start();
    latch.await(5000, TimeUnit.MILLISECONDS);
    assertTrue(inputOpened.get());
    assertTrue(sinkOpened.get());
}
 

@Override
public void destroy() {
   try {
	   LifecycleManager manager = getInstance(LifecycleManager.class);
	   if(manager != null) {
	      manager.close();
	   }
	} catch (Exception ex) {
	   // ignore
	}
}
 

private void testQueue(final Properties props) throws Exception {
    injector = LifecycleInjector.builder()
            .withBootstrapModule(new BootstrapModule() {
                @Override
                public void configure(BootstrapBinder binder) {
                    binder.bindConfigurationProvider().toInstance(new PropertiesConfigurationProvider(props));
                }
            }).build().createInjector();
    injector.getInstance(LifecycleManager.class).start();

    MessageSetProcessor queue = injector.getInstance(MessageSetProcessor.class);

    assertEquals(queue.getQueueSize(), 0);
    assertEquals(queue.getStatus(), ServiceStatus.ALIVE);

    TMessageSet messageSet = TestConnectionPool.createMessageSet(100);
    assertEquals(queue.process(messageSet).getResultCode(), ResultCode.OK);

    assertEquals(queue.getQueueSize(), 1);
    assertEquals(queue.poll(1, TimeUnit.MILLISECONDS), messageSet);
    assertEquals(queue.getQueueSize(), 0);

    queue.stopTakingTraffic();
    assertEquals(queue.process(messageSet).getResultCode(), ResultCode.OTHER_ERROR);

    queue.startTakingTraffic();
    assertEquals(queue.getStatus(), ServiceStatus.ALIVE);

    assertEquals(queue.process(messageSet).getResultCode(), ResultCode.OK);

    injector.getInstance(LifecycleManager.class).close();
}
 

@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);
    }

}
 

protected void startLifecycleManager() {
    lifecycleManager = injector.getInstance(LifecycleManager.class);
    try {
        lifecycleManager.start();
    } catch (Exception e) {
        throw new RuntimeException(e); // So that this does not pollute the API.
    }
}
 

@Before
public void setUp() throws Exception {
    injector = LifecycleInjector.bootstrap(TestableTcpModule.class);
    lifecycleManager = injector.getInstance(LifecycleManager.class);
    lifecycleManager.start();
    server = injector.getInstance(RX_SERVERS_KEY).values().iterator().next();
}
 

@Before
public void setUp() throws Exception {
    injector = LifecycleInjector.bootstrap(TestableHttpModule.class);
    lifecycleManager = injector.getInstance(LifecycleManager.class);
    lifecycleManager.start();
    server = injector.getInstance(RX_SERVERS_KEY).values().iterator().next();
}
 

@Before
public void setUp() throws Exception {
    injector = LifecycleInjector.bootstrap(TestableWebSocketsModule.class);
    lifecycleManager = injector.getInstance(LifecycleManager.class);
    lifecycleManager.start();
    server = injector.getInstance(RX_SERVERS_KEY).values().iterator().next();
}
 

public void setUp() throws Exception {
	System.setProperty("archaius.deployment.applicationId", "middletier");
	System.setProperty("archaius.deployment.environment", "ci");
    
	Injector injector = LifecycleInjector.builder().withModules(new RSSModule()).createInjector();

	LifecycleManager lifecycleManager = injector.getInstance(LifecycleManager.class);
	lifecycleManager.start();

	middleTierServer = injector.getInstance(MiddleTierServer.class);
	middleTierServer.start();
}
 

@After
public void tearDown() throws Exception {
    shutdownServers(servers);

    injector.getInstance(LifecycleManager.class).close();

    props.clear();
}
 

private void createInjector() throws Exception {
    props.put(ClientConfig.LB_SERVER, createConnectionString(servers));

    injector = LifecycleInjector.builder()
            .withBootstrapModule(new BootstrapModule() {
                @Override
                public void configure(BootstrapBinder binder) {
                    binder.bindConfigurationProvider().toInstance(new PropertiesConfigurationProvider(props));
                    binder.bind(ILoadBalancer.class).to(StaticLoadBalancer.class);
                }
            }).build().createInjector();
    injector.getInstance(LifecycleManager.class).start();
}
 

private void setupFile(final Properties props) throws Exception {
    props.put(ClientConfig.LB_SERVER, TestConnectionPool.createConnectionString(servers));
    props.put(ClientConfig.ASYNC_FILEQUEUE_PATH, tempDir.newFolder().getAbsolutePath());
    props.put(ClientConfig.ASYNC_QUEUE_TYPE, "file");

    injector = LifecycleInjector.builder()
            .withBootstrapModule(new BootstrapModule() {
                @Override
                public void configure(BootstrapBinder binder) {
                    binder.bindConfigurationProvider().toInstance(new PropertiesConfigurationProvider(props));
                    binder.bind(ILoadBalancer.class).to(StaticLoadBalancer.class);
                }
            }).build().createInjector();
    injector.getInstance(LifecycleManager.class).start();
}
 

private void setupMemory(final Properties props) throws Exception {
    injector = LifecycleInjector.builder()
            .withBootstrapModule(new BootstrapModule() {
                @Override
                public void configure(BootstrapBinder binder) {
                    binder.bindConfigurationProvider().toInstance(new PropertiesConfigurationProvider(props));
                    binder.bind(ILoadBalancer.class).to(StaticLoadBalancer.class);
                }
            }).build().createInjector();
    injector.getInstance(LifecycleManager.class).start();
}
 

@After
public void tearDown() throws Exception {
    FileUtils.deleteDirectory(new File(NON_EXISTENT_PATH));
    FileUtils.deleteQuietly(new File(TEMP_FILE));

    TestConnectionPool.shutdownServers(servers);
    injector.getInstance(LifecycleManager.class).close();

    assertFalse(String.format("The directory %s should be deleted", NON_EXISTENT_PATH), new File(NON_EXISTENT_PATH).exists());
}
 

@Override
protected void after() {
    injector.get().getInstance(LifecycleManager.class).close();
}
 

@Test
public void test() throws Exception {
    int statusPort = TestUtils.pickPort();
    int serverPort = TestUtils.pickPort();

    final Properties props = new Properties();
    props.put("SuroServer.statusServerPort", Integer.toString(statusPort));
    props.put("SuroServer.port", Integer.toString(serverPort));

    Injector injector = LifecycleInjector.builder().withBootstrapModule(new BootstrapModule() {
        @Override
        public void configure(BootstrapBinder binder) {
            binder.bindConfigurationProvider().toInstance(new PropertiesConfigurationProvider(props));
        }
    }).withModules(
            new SuroInputPlugin(),
            new AbstractModule() {
                @Override
                protected void configure() {
                    bind(ObjectMapper.class).to(DefaultObjectMapper.class);
                }
            }
    ).build().createInjector();

    LifecycleManager lifecycleManager = injector.getInstance(LifecycleManager.class);
    lifecycleManager.start();

    InputManager inputManager = new InputManager();
    List<SuroInput> inputList = injector.getInstance(ObjectMapper.class).readValue(
            inputConfig,
            new TypeReference<List<SuroInput>>() {
            });
    inputManager.set(inputList);
    assertNotNull(inputManager.getInput("thrift"));
    assertNotNull(inputManager.getInput("kafka_topic-kafka1"));

    inputList = injector.getInstance(ObjectMapper.class).readValue(
            addInputConfig,
            new TypeReference<List<SuroInput>>() {
            });
    inputManager.set(inputList);
    assertNotNull(inputManager.getInput("thrift"));
    assertNotNull(inputManager.getInput("kafka_topic-kafka1"));
    assertNotNull(inputManager.getInput("kafka_topic-kafka2"));


    inputList = injector.getInstance(ObjectMapper.class).readValue(
            inputConfig,
            new TypeReference<List<SuroInput>>() {
            });
    inputManager.set(inputList);
    assertNotNull(inputManager.getInput("thrift"));
    assertNotNull(inputManager.getInput("kafka_topic-kafka1"));
}
 

@After
public void tearDown() throws Exception {
    TestConnectionPool.shutdownServers(servers);

    injector.getInstance(LifecycleManager.class).close();
}
 

@After
public void tearDown() throws Exception {
    TestConnectionPool.shutdownServers(servers);

    injector.getInstance(LifecycleManager.class).close();
}
 

@After
public void tearDown() throws Exception {
    TestConnectionPool.shutdownServers(servers);

    injector.getInstance(LifecycleManager.class).close();
}
 

public void shutdown() {
    injector.getInstance(LifecycleManager.class).close();
}