com.google.inject.Module Java Examples

@Test
public void initializeGuice_ProvideImmutableListViaExtendingService_NoProblem() throws Exception {
    // given
    final AbstractService service = new AbstractService() {
        @Override
        public void displayHelp(PrintStream out) {

        }

        @Override
        protected List<Module> getGuiceModules() {
            return Collections.emptyList();
        }
    };

    // when
    service.initializeGuice();

    // then
    // no exception should be raised
    assertThat(service.injector).isNotNull();
}
 

public static void startIrisSystem(Collection<? extends Class<? extends Module>> extra) throws Exception {
   File basePath = BASE_PATH.get();
   if (basePath != null) {
      throw new IllegalStateException("iris test harness already started: " + basePath);
   }

   basePath = Files.createTempDir();
   if (!BASE_PATH.compareAndSet(null, basePath)) {
      FileUtils.deleteDirectory(basePath);
      throw new IllegalStateException("iris test harness startup race condition");
   }

   System.out.println("Starting up simulated iris hal: " + basePath + "...");
   FileUtils.deleteDirectory(basePath);

   BootUtils.addExtraModules(extra);
   BootUtils.initialize(new IrisHalTest(), basePath, Collections.<String>emptyList());
}
 

@Test
public void testModulesRegisteredThroughInjectionWithAnnotation() throws Exception
{
    final Injector injector = Guice.createInjector(
            new ObjectMapperModule().registerModule(IntegerAsBase16Module.class, Ann.class),
            new Module()
            {
                @Override
                public void configure(Binder binder)
                {
                    binder.bind(IntegerAsBase16Module.class).annotatedWith(Ann.class).to(IntegerAsBase16Module.class);
                }
            }
    );

    final ObjectMapper mapper = injector.getInstance(ObjectMapper.class);

    Assert.assertEquals(mapper.writeValueAsString(Integer.valueOf(10)), "\"A\"");
}
 

/**
 * <pre>
 * Given => Custom interceptor is configured
 * When  => String message is handled
 * Then  => Interceptor has been called
 * </pre>
 */
@Test
public void handleString_interceptorConfigured_interceptorIsCalled() throws InvocationTargetException, IllegalAccessException {
    // given
    Module sagaModule = SagaModuleBuilder.configure().callInterceptor(CustomInterceptor.class).build();
    Injector injector = Guice.createInjector(sagaModule, new CustomModule());
    MessageStream msgStream = injector.getInstance(MessageStream.class);
    Set<SagaLifetimeInterceptor> interceptors = injector.getInstance(Key.get(new TypeLiteral<Set<SagaLifetimeInterceptor>>() {}));

    // when
    msgStream.handle("anyString");

    // then
    CustomInterceptor interceptor = (CustomInterceptor) interceptors.iterator().next();
    assertThat("Expected interceptor to be called.", interceptor.hasStartingBeenCalled(), equalTo(true));
}
 

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

@Override
public Module module(final Key<PluginSource> key, final String id) {
    return new PrivateModule() {
        @Override
        protected void configure() {
            bind(ProtocolServer.class).to(protocolServer).in(Scopes.SINGLETON);
            bind(Protocol.class).toInstance(protocol);

            bind(RiemannFrameDecoder.class);
            bind(RiemannResponder.class).in(Scopes.SINGLETON);
            bind(RiemannDatagramDecoder.class).in(Scopes.SINGLETON);
            bind(RiemannMessageDecoder.class).in(Scopes.SINGLETON);
            bind(Logger.class).toInstance(log);

            bind(RetryPolicy.class).toInstance(retry);

            bind(key).to(ProtocolPluginSource.class).in(Scopes.SINGLETON);
            expose(key);
        }
    };
}
 

public static ComputeService buildDefaultComputeService(IaasProvider iaasProvider) {

        Properties properties = new Properties();

        // load properties
        for (Map.Entry<String, String> entry : iaasProvider.getProperties().entrySet()) {
            properties.put(entry.getKey(), entry.getValue());
        }

        // set modules
        Iterable<Module> modules =
                ImmutableSet.<Module>of(new SshjSshClientModule(), new SLF4JLoggingModule(),
                        new EnterpriseConfigurationModule());

        // build context
        ContextBuilder builder =
                ContextBuilder.newBuilder(iaasProvider.getProvider())
                        .credentials(iaasProvider.getIdentity(), iaasProvider.getCredential()).modules(modules)
                        .overrides(properties);

        return builder.buildView(ComputeServiceContext.class).getComputeService();
    }
 

public static Module kerberosHdfsAuthenticationModule()
{
    return new Module()
    {
        @Override
        public void configure(Binder binder)
        {
            binder.bind(HdfsAuthentication.class)
                    .to(DirectHdfsAuthentication.class)
                    .in(SINGLETON);
            configBinder(binder).bindConfig(HdfsKerberosConfig.class);
        }

        @Inject
        @Provides
        @Singleton
        @ForHdfs
        HadoopAuthentication createHadoopAuthentication(HdfsKerberosConfig config, HdfsConfigurationInitializer updater)
        {
            String principal = config.getHdfsPrestoPrincipal();
            String keytabLocation = config.getHdfsPrestoKeytab();
            return createCachingKerberosHadoopAuthentication(principal, keytabLocation, updater);
        }
    };
}
 

private void copyToS3( String fileName ) {

        String bucketName = ( String ) properties.get( BUCKET_PROPNAME );
        String accessId = ( String ) properties.get( ACCESS_ID_PROPNAME );
        String secretKey = ( String ) properties.get( SECRET_KEY_PROPNAME );

        Properties overrides = new Properties();
        overrides.setProperty( "s3" + ".identity", accessId );
        overrides.setProperty( "s3" + ".credential", secretKey );

        final Iterable<? extends Module> MODULES = ImmutableSet
                .of( new JavaUrlHttpCommandExecutorServiceModule(), new Log4JLoggingModule(),
                        new NettyPayloadModule() );

        AWSCredentials credentials = new BasicAWSCredentials(accessId, secretKey);
        ClientConfiguration clientConfig = new ClientConfiguration();
        clientConfig.setProtocol( Protocol.HTTP);

        AmazonS3Client s3Client = new AmazonS3Client(credentials, clientConfig);

        s3Client.createBucket( bucketName );
        File uploadFile = new File( fileName );
        PutObjectResult putObjectResult = s3Client.putObject( bucketName, uploadFile.getName(), uploadFile );
        logger.info("Uploaded file etag={}", putObjectResult.getETag());
    }
 

private List<Module> buildAdminPluginsGuiceModules() {
    List<Module> guiceModules = new ArrayList<>();
    if (adminPageRegistry != null) {
        final Collection<AdminPageInfo> allPages = adminPageRegistry.getAllPages();
        for (AdminPageInfo adminPlugin : allPages) {
            logger.info("Adding admin page {}: jersey={} modules{}", 
                    adminPlugin.getName(),
                    adminPlugin.getJerseyResourcePackageList(),
                    adminPlugin.getGuiceModules());
            final List<Module> guiceModuleList = adminPlugin.getGuiceModules();
            if (guiceModuleList != null && !guiceModuleList.isEmpty()) {
                guiceModules.addAll(adminPlugin.getGuiceModules());
            }
        }
    }
    guiceModules.add(getAdditionalBindings());
    return guiceModules;
}
 

@Override
public Module newConfigModule() {
    return new AbstractModule() {

        @Override
        protected void configure() {
            bind(ServerSession.class).toInstance(session);
        }
    };
}
 

private JenkinsApi createApi(final String endPoint, final JenkinsAuthentication authentication, final Properties overrides, final List<Module> modules) {
    final List<Module> allModules = Lists.newArrayList(new JenkinsAuthenticationModule(authentication));
    if (modules != null) {
        allModules.addAll(modules);
    }
    return ContextBuilder
            .newBuilder(new JenkinsApiMetadata.Builder().build())
            .endpoint(endPoint)
            .modules(allModules)
            .overrides(overrides)
            .buildApi(JenkinsApi.class);
}
 

public Builder() {
   id("aws-ec2")
   .version("2014-02-01")
   .name("Amazon-specific EC2 API")
   .identityName("Access Key ID")
   .credentialName("Secret Access Key")
   .defaultEndpoint("https://ec2.us-east-1.amazonaws.com")
   .documentation(URI.create("http://docs.amazonwebservices.com/AWSEC2/latest/APIReference"))
   .defaultProperties(AWSEC2ApiMetadata.defaultProperties())
   .view(AWSEC2ComputeServiceContext.class)
   .defaultModules(ImmutableSet.<Class<? extends Module>>of(AWSEC2HttpApiModule.class, EC2ResolveImagesModule.class, AWSEC2ComputeServiceContextModule.class));
}
 

@Override
public Module getModule() {
    List<Module> modules = subrule
                .stream()
                .map(GuiceModuleTestRule::getModule)
                .collect(Guavate.toImmutableList());

    return Modules.combine(modules);
}
 

private void buildNeutronApi() {

        String iaasProviderNullMsg = "IaasProvider is null. Unable to build neutron API";
        assertNotNull(iaasProvider, iaasProviderNullMsg);

        String region = ComputeServiceBuilderUtil.extractRegion(iaasProvider);
        String regionNullOrEmptyErrorMsg = String.format("Region is not set. Unable to build neutron API for the iaas provider %s",
                iaasProvider.getProvider());
        assertNotNullAndNotEmpty(region, regionNullOrEmptyErrorMsg);

        String endpoint = iaasProvider.getProperty(CloudControllerConstants.JCLOUDS_ENDPOINT);
        String endpointNullOrEmptyErrorMsg = String.format("Endpoint is not set. Unable to build neutorn API for the iaas provider %s",
                iaasProvider.getProvider());
        assertNotNullAndNotEmpty(endpoint, endpointNullOrEmptyErrorMsg);

        Iterable<Module> modules = ImmutableSet.<Module>of(new SLF4JLoggingModule());

        try {
            this.neutronApi = ContextBuilder.newBuilder(provider).credentials(iaasProvider.getIdentity(),
                    iaasProvider.getCredential()).endpoint(endpoint).modules(modules).buildApi(NeutronApi.class);
        } catch (Exception e) {
            String msg = String.format("Unable to build neutron API for [provider=%s, identity=%s, credential=%s, endpoint=%s]",
                    provider, iaasProvider.getIdentity(), iaasProvider.getCredential(), endpoint);
            log.error(msg, e);
            throw new CloudControllerException(msg, e);
        }

        this.portApi = neutronApi.getPortApi(region);
        String portApiNullOrEmptyErrorMessage = String.format("Unable to get port Api from neutron Api for region ", region);
        assertNotNull(portApi, portApiNullOrEmptyErrorMessage);

        this.floatingIPApi = neutronApi.getFloatingIPApi(region).get();
        String floatingIPApiNullOrEmptyErrorMessage = String.format("Unable to get floatingIP Api from neutron Api for region ", region);
        assertNotNull(floatingIPApi, floatingIPApiNullOrEmptyErrorMessage);
    }
 

/**
 * @param modules overriding guice modules to register
 */
public void registerModulesOverride(final Module... modules) {
    ModuleItemInfoImpl.overrideScope(() -> {
        for (Module module : modules) {
            register(ConfigItem.Module, module);
        }
    });
}
 

@Test
public void testFairSchedulerWebAppPage() {
  List<RMAppState> appStates = Arrays.asList(RMAppState.NEW,
      RMAppState.NEW_SAVING, RMAppState.SUBMITTED);
  final RMContext rmContext = mockRMContext(appStates);
  Injector injector = WebAppTests.createMockInjector(RMContext.class,
      rmContext,
      new Module() {
        @Override
        public void configure(Binder binder) {
          try {
            ResourceManager mockRmWithFairScheduler =
                mockRm(rmContext);
            binder.bind(ResourceManager.class).toInstance
                (mockRmWithFairScheduler);
            binder.bind(ApplicationBaseProtocol.class).toInstance(
              mockRmWithFairScheduler.getClientRMService());
          } catch (IOException e) {
            throw new IllegalStateException(e);
          }
        }
      });
  FairSchedulerPage fsViewInstance = injector.getInstance(FairSchedulerPage
      .class);
  fsViewInstance.render();
  WebAppTests.flushOutput(injector);
}
 

/**
 * Guice module manual disable registration from
 * {@link ru.vyarus.dropwizard.guice.GuiceBundle.Builder#disableModules(Class[])}.
 *
 * @param modules modules to disable
 */
@SuppressWarnings("PMD.UseVarargs")
public void disableModules(final Class<? extends Module>[] modules) {
    for (Class<? extends Module> module : modules) {
        registerDisable(ConfigItem.Module, ItemId.from(module));
    }
}
 

@Override
public final Injector get(T configuration, Environment environment, Module additionalModule)
{
    List<Module> localModules = Lists.newArrayList();
    Collections.addAll(localModules, modules);
    if ( additionalModule != null )
    {
        localModules.add(additionalModule);
    }
    internalAddModules(localModules, configuration, environment);
    return Guice.createInjector(localModules);
}
 

private Module createModule(ITestContext testContext, String name) {
  final Iterator<TckModule> moduleIterator = ServiceLoader.load(TckModule.class).iterator();
  if (!moduleIterator.hasNext()) {
    throw new IllegalStateException(
        format(
            "Couldn't find a TckModule configuration. "
                + "You probably forgot to configure resources/META-INF/services/%s, or even "
                + "provide an implementation of the TckModule which is required by the jpa test class %s",
            TckModule.class.getName(), name));
  }
  return new CompoundModule(testContext, moduleIterator);
}
 

private DefaultApplicationContext newApplicationContext() {
        ProfilerConfig profilerConfig = spy(new DefaultProfilerConfig());
        when(profilerConfig.getStaticResourceCleanup()).thenReturn(true);
//        when(profilerConfig.getTransportModule()).thenReturn("GRPC");

        Instrumentation instrumentation = mock(Instrumentation.class);
        AgentOption agentOption = new DefaultAgentOption(instrumentation, "mockAgent", "mockApplicationName", false,
                profilerConfig, Collections.<String>emptyList(), null);

        InterceptorRegistryBinder interceptorRegistryBinder = new TestInterceptorRegistryBinder();
        Module interceptorRegistryModule = InterceptorRegistryModule.wrap(interceptorRegistryBinder);
        ModuleFactory moduleFactory = new OverrideModuleFactory(interceptorRegistryModule);

        return new DefaultApplicationContext(agentOption, moduleFactory);
    }
 

public BackupModule(Map<String, Module> providers)
{
    this.providers = ImmutableMap.<String, Module>builder()
            .put("file", new FileBackupModule())
            .put("http", new HttpBackupModule())
            .putAll(providers)
            .build();
}
 

public Builder withModuleClassnames(Collection<String> classes) throws ClassNotFoundException {
   if(classes != null) {
      Set<Class<? extends Module>> moduleClasses = classnamesToClasses(classes);
      this.moduleClasses.addAll(moduleClasses);
   }

   return this;
}
 

@Override
protected List<Module> getModules() {
    List<Module> modules = new ArrayList<Module>();
    modules.add(new Module() {
        @Override
        public void configure(Binder binder) {
            binder.bind(BookService.class);
            binder.bind(BookStorage.class);
            binder.bind(BookNotFoundExceptionMapper.class);
        }
    });
    return modules;
}
 

/**
 * Here we override the childModule if it is a {@link DefaultSharedContribution}. In that case, we enhance it with
 * the {@link ProjectStateChangeListenerModule}.
 *
 * @param childModule
 *            the module that shall be used to configure the contribution.
 */
@Override
public SharedStateContribution createContribution(Module childModule) {
	if (childModule.getClass().equals(DefaultSharedContribution.class)) {
		childModule = Modules.override(childModule).with(new ProjectStateChangeListenerModule());
	}
	return super.createContribution(childModule);
}
 

@BeforeMethod
public void beforeMethod() throws Exception {

    TSOServerConfig tsoConfig = new TSOServerConfig();
    tsoConfig.setConflictMapSize(1000);
    tsoConfig.setPort(TSO_SERVER_PORT);
    tsoConfig.setNumConcurrentCTWriters(2);
    Module tsoServerMockModule = new TSOMockModule(tsoConfig);
    Injector injector = Guice.createInjector(tsoServerMockModule);

    LOG.info("==================================================================================================");
    LOG.info("======================================= Init TSO Server ==========================================");
    LOG.info("==================================================================================================");

    tsoServer = injector.getInstance(TSOServer.class);
    tsoServer.startAndWait();
    TestUtils.waitForSocketListening(TSO_SERVER_HOST, TSO_SERVER_PORT, 100);

    LOG.info("==================================================================================================");
    LOG.info("===================================== TSO Server Initialized =====================================");
    LOG.info("==================================================================================================");

    pausableTSOracle = (PausableTimestampOracle) injector.getInstance(TimestampOracle.class);
    commitTable = injector.getInstance(CommitTable.class);

    OmidClientConfiguration tsoClientConf = new OmidClientConfiguration();
    tsoClientConf.setConnectionString(TSO_SERVER_HOST + ":" + TSO_SERVER_PORT);

    this.tsoClientConf = tsoClientConf;

}
 

@org.junit.Test public void testLabelProviderInjection() throws Exception {
	Module module = new Module() {
		@Override
		public void configure(Binder binder) {
			binder.bind(ILabelProvider.class).annotatedWith(ResourceServiceDescriptionLabelProvider.class).to(LabelProvider.class);
		}
	};
	Injector injector = Guice.createInjector(module);
	Test instance = injector.getInstance(Test.class);
	assertTrue(instance.labelProvider instanceof LabelProvider);
}
 

private static Module newServerBinding(final String serverBinding) {
    return new AbstractModule() {

        @Override
        protected void configure() {
            bind(String.class).annotatedWith(Names.named("serverBinding")).toInstance(serverBinding);
        }
    };
}
 

public static DefaultApplicationContext newMockApplicationContext(ProfilerConfig profilerConfig) {

        Module loggingModule = new LoggingModule();

        InterceptorRegistryBinder interceptorRegistryBinder = new EmptyInterceptorRegistryBinder();
        Module interceptorRegistryModule = InterceptorRegistryModule.wrap(interceptorRegistryBinder);
        ModuleFactory moduleFactory = new OverrideModuleFactory(loggingModule, interceptorRegistryModule);

        MockApplicationContextFactory factory = new MockApplicationContextFactory();
        return factory.build(profilerConfig, moduleFactory);
    }
 

public static Module mixin(Module...m) {
	if (m.length==0)
		return null;
	Module current = m[0];
	for (int i=1;i<m.length;i++) {
		current = Modules.override(current).with(m[i]);
	}
	return current;
}