com.netflix.governator.guice.BootstrapModule Java Examples

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

@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 static void create(AtomicReference<Injector> injector, final Properties properties, Module... modules) throws Exception {
    // Create the injector
    injector.set(LifecycleInjector.builder()
            .withBootstrapModule(
                    new BootstrapModule() {
                        @Override
                        public void configure(BootstrapBinder binder) {
                            binder.bindConfigurationProvider().toInstance(
                                    new PropertiesConfigurationProvider(properties));
                        }
                    }
            )
            .withModules(
                    new RoutingPlugin(),
                    new ServerSinkPlugin(),
                    new SuroInputPlugin(),
                    new SuroDynamicPropertyModule(),
                    new SuroModule(),
                    StatusServer.createJerseyServletModule()
            )
            .withAdditionalModules(modules)
            .build().createInjector());
}
 

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

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

public Injector bootstrap() {
   try {
      // Construct the injector
      LifecycleInjectorBuilder builder = LifecycleInjector.builder()
         .withBootstrapModule(new BootstrapModule() {
            @Override
            public void configure(@Nullable BootstrapBinder binder) {
               Preconditions.checkNotNull(binder);
               binder.bindConfigurationProvider().to(AgentConfigurationProvider.class);
            }
         })
         .withAdditionalBootstrapModules(boostrapModules);

      builder.withAdditionalModuleClasses(moduleClasses);
      if(!modules.isEmpty()) {
         builder.withAdditionalModules(modules);
      }

      LifecycleInjector inj = builder.build();
      Injector result = inj.createInjector();
      LifeCycleService.setState(LifeCycle.STARTING_UP, LifeCycle.STARTED);
      return result;
   } catch(Exception ex) {
      throw new BootException("error bootstrapping", ex);
   }
}
 

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

public static Injector initialize(@Nullable IrisHalInternal hal, File basePath, Collection<String> configFiles) {
   Set<File> configs = resolveConfigs(configFiles);

   if (hal != null) {
      IrisHal.start(basePath, configs, hal);
   } else {
      IrisHal.start(basePath, configs);
   }

   Collection<BootstrapModule> bmodules = new LinkedList<>();
   bmodules.addAll(IrisHal.getBootstrapModules());

   Collection<Class<? extends BootstrapModule>> bmoduleClasses = new LinkedList<>();
   bmoduleClasses.addAll(IrisHal.getBootstrapModuleClasses());

   Collection<Module> modules = new LinkedList<>();
   modules.addAll(IrisHal.getApplicationModules());

   Collection<Class<? extends Module>> moduleClasses = new LinkedList<>();
   moduleClasses.addAll(EXTRA);
   moduleClasses.addAll(IrisHal.getApplicationModuleClasses());
   moduleClasses.add(MessagesModule.class);
   moduleClasses.add(ProtocolMessagesModule.class);
   moduleClasses.add(GsonModule.class);
   moduleClasses.add(AgentModule.class);

   Bootstrap.Builder builder = Bootstrap.builder();
   builder.withBootstrapModules(bmodules);
   builder.withBootstrapModuleClasses(bmoduleClasses);
   builder.withModules(modules);
   builder.withModuleClasses(moduleClasses);

   Injector injector = builder.build().bootstrap();
   ServiceLocator.init(GuiceServiceLocator.create(injector));

   Runtime.getRuntime().addShutdownHook(new Thread(IrisShutdownHook.INSTANCE));
   return injector;
}
 

public Injector bootstrap() throws BootstrapException {
   try {
      final Properties merged = mergeProperties();

      LifecycleInjectorBuilder builder = LifecycleInjector.builder()
         .withBootstrapModule(new BootstrapModule() {
            @Override
            public void configure(BootstrapBinder binder) {
               Names.bindProperties(binder, merged);
               binder.bindConfigurationProvider().toInstance(new PropertiesConfigurationProvider(merged));
            }
         })
         .withAdditionalBootstrapModules(boostrapModules);

      if(merged.containsKey(PROP_MODULES)) {
         String [] classnames = StringUtils.split(merged.getProperty(PROP_MODULES));
         Set<Class<? extends Module>> modules = classnamesToClasses(Arrays.asList(classnames));
         modules.addAll(moduleClasses);
         builder.withAdditionalModuleClasses(modules);
      }
      else if(!moduleClasses.isEmpty()) {
         builder.withAdditionalModuleClasses(moduleClasses);
      }
      if(!modules.isEmpty()) {
         builder.withAdditionalModules(modules);
      }

      return builder.build().createInjector();
   } catch(Exception e) {
      throw new BootstrapException("Error bootstrapping the injection context", e);
   }
}
 

public final void startWithAdditionalBootstrapModules(BootstrapModule... additionalBootstrapModules) {
    BootstrapModule[] applicableBootstrapModules = this.bootstrapModules;
    if (null != additionalBootstrapModules && additionalBootstrapModules.length != 0) {
        applicableBootstrapModules = Arrays.copyOf(bootstrapModules, bootstrapModules.length + additionalBootstrapModules.length);
        System.arraycopy(additionalBootstrapModules, 0, applicableBootstrapModules, bootstrapModules.length, additionalBootstrapModules.length);
    }

    injector = newInjector(applicableBootstrapModules);

    startLifecycleManager();
    _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();
}
 

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

/**
 * Creates a new {@link KaryonServer} that has a single HTTP server instance which delegates all request
 * handling to {@link RequestHandler}.
 * The {@link HttpServer} is created using {@link KaryonTransport#newHttpServer(int, HttpRequestHandler)}
 *
 * @param port Port for the server.
 * @param handler Request Handler
 * @param bootstrapModules Additional bootstrapModules if any.
 *
 * @return {@link KaryonServer} which is to be used to start the created server.
 */
public static KaryonServer forRequestHandler(int port, final RequestHandler<ByteBuf, ByteBuf> handler,
                                             BootstrapModule... bootstrapModules) {
    HttpServer<ByteBuf, ByteBuf> httpServer =
            KaryonTransport.newHttpServer(port, new RequestHandler<ByteBuf, ByteBuf>() {
                @Override
                public Observable<Void> handle(HttpServerRequest<ByteBuf> request,
                                               HttpServerResponse<ByteBuf> response) {
                    return handler.handle(request, response);
                }
            });
    return new RxNettyServerBackedServer(httpServer, bootstrapModules);
}
 

public static BootstrapModule toBootstrapModule(final Module... modules) {
    if (null == modules) {
        return null;
    }
    return new BootstrapModule() {
        @Override
        public void configure(BootstrapBinder binder) {
            binder.includeModules(modules);
        }

    };
}
 

@SafeVarargs
public static BootstrapModule toBootstrapModule(final Class<? extends Module>... moduleClasses) {
    if (null == moduleClasses) {
        return null;
    }
    return new BootstrapModule() {
        @Override
        public void configure(BootstrapBinder binder) {
            binder.include(Lists.newArrayList(moduleClasses));
        }

    };
}
 

public static BootstrapModule toBootstrapModule(final Class<? extends Module> moduleClass) {
    if (null == moduleClass) {
        return null;
    }
    return new BootstrapModule() {
        @Override
        public void configure(BootstrapBinder binder) {
            binder.include(moduleClass);
        }

    };
}
 

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

RxNettyServerBackedServer(AbstractServer rxNettyServer, BootstrapModule... bootstrapModules) {
    super(RxNettyServerBackedServer.class, bootstrapModules);
    this.rxNettyServer = rxNettyServer;
}
 

public AbstractKaryonServer(BootstrapModule... bootstrapModules) {
    this.bootstrapModules = bootstrapModules;
}
 

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

KaryonServerBackedServer(AbstractKaryonServer delegate, BootstrapModule... bootstrapModules) {
    this.delegate = delegate;
    this.bootstrapModules = bootstrapModules;
}
 

public static BootstrapModule asBootstrapModule() {
    return asBootstrapModule(7002);
}
 

public static BootstrapModule asBootstrapModule(final int port) {
    return Karyon.toBootstrapModule(new ShutdownModule(port));
}
 

protected MainClassBasedServer(Class<?> mainClass, BootstrapModule... bootstrapModules) {
    super(bootstrapModules);
    this.mainClass = mainClass;
}
 

@Override
protected Injector newInjector(BootstrapModule... applicableBootstrapModules) {
    return LifecycleInjector.bootstrap(mainClass, applicableBootstrapModules);
}
 

@BeforeClass
public static void setUpBefore() throws Exception {
  server = Karyon.forApplication( JerseyBlockingModule.class, (BootstrapModule[])null );
    
  server.start();
}
 

public static BootstrapModule asBootstrapModule() {
    return Karyon.toBootstrapModule(KaryonEurekaModule.class);
}
 

public static Collection<? extends BootstrapModule> getBootstrapModules() {
   return get().getBootstrapModules();
}
 

public static Collection<Class<? extends BootstrapModule>> getBootstrapModuleClasses() {
   return get().getBootstrapModuleClasses();
}