@Override
  public void configure(final Binder binder) {
    final ExportBuilder builder = MBeanModule.newExporter(binder);

    binder.bind(PersistentWriterFactory.class).to(EventSpoolWriterFactory.class).asEagerSingleton();

    Multibinder<EventSpoolProcessor> defaultSpoolProcessors =
        Multibinder.newSetBinder(binder, EventSpoolProcessor.class);

    MapBinder<String, EventSpoolProcessor> perEventSpoolDispatchers =
        MapBinder.newMapBinder(binder, String.class, EventSpoolProcessor.class).permitDuplicates();

    String spoolWriterClasses = config.getSpoolWriterClassNames();
    final Iterable<String> spoolDispatcherClasses;

    if (!Strings.isNullOrEmpty(spoolWriterClasses)) {
      spoolDispatcherClasses =
          Splitter.on(",").trimResults().omitEmptyStrings().split(spoolWriterClasses);
    } else {
      spoolDispatcherClasses = Lists.newArrayList();
    }

    // Bind the classes for default spoolClasses
    for (String className : spoolDispatcherClasses) {
      try {
        defaultSpoolProcessors
            .addBinding()
            .to(Class.forName(className).asSubclass(EventSpoolProcessor.class))
            .asEagerSingleton();
      } catch (ClassNotFoundException e) {
        log.error("Could not bind " + className, e);
      }
    }

    // Find and bind the classes used for per event spool writers
    Map<String, Iterable<String>> perEventSpoolWriterClasses = getSpoolWriterClassesByEventType();

    for (Map.Entry<String, Iterable<String>> eventToSpoolWriters :
        perEventSpoolWriterClasses.entrySet()) {
      for (String spoolWriterClass : eventToSpoolWriters.getValue()) {

        try {
          perEventSpoolDispatchers
              .addBinding(eventToSpoolWriters.getKey())
              .to(Class.forName(spoolWriterClass).asSubclass(EventSpoolProcessor.class));
        } catch (ClassNotFoundException ex) {
          log.error("Could not bind " + spoolWriterClass, ex);
        }
      }
    }

    builder
        .export(EventSpoolWriterFactory.class)
        .as("com.ning.metrics.collector:name=EventSpoolWriter");
  }
  @Override
  protected void configure() {
    LOGGER.debug("Configuring guice");
    bind(MyriadConfiguration.class).toInstance(cfg);
    bind(Configuration.class).toInstance(hadoopConf);
    bind(RMContext.class).toInstance(rmContext);
    bind(AbstractYarnScheduler.class).toInstance(yarnScheduler);
    bind(InterceptorRegistry.class).toInstance(interceptorRegistry);
    bind(MyriadDriverManager.class).in(Scopes.SINGLETON);
    bind(org.apache.myriad.scheduler.MyriadScheduler.class).in(Scopes.SINGLETON);
    bind(ServiceProfileManager.class).in(Scopes.SINGLETON);
    bind(DisruptorManager.class).in(Scopes.SINGLETON);
    bind(ReconcileService.class).in(Scopes.SINGLETON);
    bind(HttpConnectorProvider.class).in(Scopes.SINGLETON);
    bind(MyriadWebServer.class).in(Scopes.SINGLETON);
    // add special binding between TaskFactory and NMTaskFactory to ease up
    // usage of TaskFactory
    bind(TaskFactory.class).annotatedWith(NMTaskFactoryAnnotation.class).to(NMTaskFactory.class);
    bind(YarnNodeCapacityManager.class).in(Scopes.SINGLETON);
    bind(NodeStore.class).in(Scopes.SINGLETON);
    bind(OfferLifecycleManager.class).in(Scopes.SINGLETON);
    bind(NMHeartBeatHandler.class).asEagerSingleton();

    MapBinder<String, TaskFactory> mapBinder =
        MapBinder.newMapBinder(binder(), String.class, TaskFactory.class);
    mapBinder
        .addBinding(NodeManagerConfiguration.DEFAULT_NM_TASK_PREFIX)
        .to(NMTaskFactory.class)
        .in(Scopes.SINGLETON);

    Map<String, ServiceConfiguration> auxServicesConfigs = cfg.getServiceConfigurations();
    for (Map.Entry<String, ServiceConfiguration> entry : auxServicesConfigs.entrySet()) {
      if (entry.getValue().getTaskFactoryImplName().isPresent()) {
        String taskFactoryClass = entry.getValue().getTaskFactoryImplName().get();
        try {
          Class<? extends TaskFactory> implClass = getTaskFactoryClass(taskFactoryClass);
          mapBinder.addBinding(entry.getKey()).to(implClass).in(Scopes.SINGLETON);
        } catch (ClassNotFoundException e) {
          LOGGER.error("ClassNotFoundException", e);
        }
      } else {
        // TODO (hokiegeek2) Confirm if this else statement and logic should still be here
        mapBinder.addBinding(entry.getKey()).to(ServiceTaskFactory.class).in(Scopes.SINGLETON);
      }
    }

    // TODO(Santosh): Should be configurable as well
    bind(NodeScaleDownPolicy.class).to(LeastAMNodesFirstPolicy.class).in(Scopes.SINGLETON);
  }
  @Override
  protected void configureConnections(PrivateBinder binder) {
    binder.bind(QueryFactory.class).to(LdapQueryFactory.class);
    binder.bind(LdapTokenAttributeConversion.class);
    binder.bind(LdapSearchHandler.class);
    binder.bind(EntryPartialTokenConverter.class);
    binder.bind(EntryTokenConverter.class);
    binder.bind(LdapQueryBuilder.class);
    binder.bind(LdapQueryFactory.class);
    binder
        .bind(ConnectionConfig.class)
        .annotatedWith(Names.named(DataLayerConstants.EXTERNAL_CONFIG))
        .toProvider(ExternalConnectionConfigProvider.class);
    binder.bind(ConnectionFactoryProvider.class).to(LdapConnectionFactoryProvider.class);
    binder.bind(ConnectionFactory.class).toProvider(getConnectionFactoryProviderType());

    MapBinder<Class, EntryConverter> entryConverterBinder =
        MapBinder.newMapBinder(binder, Class.class, EntryConverter.class);
    entryConverterBinder.addBinding(String.class).to(EntryStringConverter.class);
    entryConverterBinder.addBinding(PartialToken.class).to(EntryPartialTokenConverter.class);
    entryConverterBinder.addBinding(Token.class).to(EntryTokenConverter.class);

    binder
        .bind(LdapDataLayerConfiguration.class)
        .to(getLdapConfigurationType())
        .in(Singleton.class);
    binder
        .bind(Key.get(LdapDataLayerConfiguration.class, DataLayer.Types.typed(connectionType)))
        .toProvider(binder.getProvider(LdapDataLayerConfiguration.class));
    binder.expose(Key.get(LdapDataLayerConfiguration.class, DataLayer.Types.typed(connectionType)));
  }
 protected void configureEventHandlers() {
   MapBinder<String, EventHandler> eventBinder =
       MapBinder.newMapBinder(binder(), String.class, EventHandler.class);
   for (Class<? extends EventHandler> clazz : EventHandlerLoader.getClasses()) {
     if (clazz.isAnnotationPresent(HandlerTarget.class)) {
       HandlerTarget targetAnnotation = clazz.getAnnotation(HandlerTarget.class);
       eventBinder.addBinding(targetAnnotation.value()).to(clazz).asEagerSingleton();
     }
   }
 }
  @Override
  public void configure(Binder binder) {
    PolyBind.createChoice(
        binder, "druid.indexer.logs.type", Key.get(TaskLogs.class), Key.get(FileTaskLogs.class));
    JsonConfigProvider.bind(binder, "druid.indexer.logs", FileTaskLogsConfig.class);

    final MapBinder<String, TaskLogs> taskLogBinder = Binders.taskLogsBinder(binder);
    taskLogBinder.addBinding("noop").to(NoopTaskLogs.class).in(LazySingleton.class);
    taskLogBinder.addBinding("file").to(FileTaskLogs.class).in(LazySingleton.class);
    binder.bind(NoopTaskLogs.class).in(LazySingleton.class);
    binder.bind(FileTaskLogs.class).in(LazySingleton.class);

    binder.bind(TaskLogPusher.class).to(TaskLogs.class);
  }
示例#6
0
  @BeforeMethod
  public void startUp() {
    Injector injector =
        Guice.createInjector(
            Stage.PRODUCTION,
            new JsonModule(),
            new HandleJsonModule(),
            binder -> {
              MapBinder<String, ConnectorHandleResolver> connectorHandleResolverBinder =
                  MapBinder.newMapBinder(binder, String.class, ConnectorHandleResolver.class);
              connectorHandleResolverBinder
                  .addBinding("system")
                  .toInstance(new SystemHandleResolver(CONNECTOR_ID));
            });

    objectMapper = injector.getInstance(ObjectMapper.class);
  }
示例#7
0
    /**
     * Starts the test app in a background thread.
     *
     * @param args String[] emulating command-line arguments passed to a Java app.
     * @return {@link BQDaemonTestRuntime} instance created by the builder. The caller doesn't need
     *     to shut it down. Usually JUnit lifecycle takes care of it.
     */
    public BQDaemonTestRuntime start(String... args) {

      Consumer<Bootique> localConfigurator = configurator;

      if (!properties.isEmpty()) {

        Consumer<Bootique> propsConfigurator =
            bootique ->
                bootique.module(
                    binder -> {
                      MapBinder<String, String> mapBinder =
                          BQCoreModule.contributeProperties(binder);
                      properties.forEach((k, v) -> mapBinder.addBinding(k).toInstance(v));
                    });

        localConfigurator = localConfigurator.andThen(propsConfigurator);
      }

      BQDaemonTestRuntime runtime = new BQDaemonTestRuntime(localConfigurator, startupCheck, args);
      runtimes.add(runtime);
      runtime.start(startupTimeout, startupTimeoutTimeUnit);
      return runtime;
    }
  @Override
  protected void configureHandlers() {
    // Handler bindings in alphabetical order
    serve(GET, handlerPrefix.prefixPath("/"), HomeHandler.class);
    serve(POST, handlerPrefix.prefixPath("/cache"), FileCacheHandler.class);
    serve(GET, handlerPrefix.prefixPath("/capture"), CaptureHandler.class);
    serve(GET, handlerPrefix.prefixPath("/capture/*"), CaptureHandler.class);
    serve(GET, handlerPrefix.prefixPath("/cmd"), CommandGetHandler.class);
    serve(POST, handlerPrefix.prefixPath("/cmd"), CommandPostHandler.class);
    serve(GET, handlerPrefix.prefixPath("/favicon.ico"), FaviconHandler.class);
    serve(GET, handlerPrefix.prefixPath("/fileSet"), FileSetGetHandler.class);
    serve(POST, handlerPrefix.prefixPath("/fileSet"), FileSetPostHandler.class);

    for (HttpMethod method : HttpMethod.values()) {
      serve(method, handlerPrefix.prefixPath("/forward/*"), ForwardingHandler.class);
    }

    serve(GET, handlerPrefix.prefixPath("/heartbeat"), HeartbeatGetHandler.class);
    serve(POST, handlerPrefix.prefixPath("/heartbeat"), HeartbeatPostHandler.class);
    serve(GET, handlerPrefix.prefixPath("/proxy", JSTD), GatewayConfigurationHandler.class);
    serve(POST, handlerPrefix.prefixPath("/proxy", JSTD), GatewayConfigurationHandler.class);
    serve(GET, handlerPrefix.prefixPath("/gateway", JSTD), GatewayConfigurationHandler.class);
    serve(POST, handlerPrefix.prefixPath("/gateway", JSTD), GatewayConfigurationHandler.class);

    serve(GET, handlerPrefix.prefixPath("/hello"), HelloHandler.class);
    serve(POST, handlerPrefix.prefixPath("/log"), BrowserLoggingHandler.class);
    serve(POST, handlerPrefix.prefixPath("/query/*"), BrowserQueryResponseHandler.class);
    serve(GET, handlerPrefix.prefixPath("/runner/*"), StandaloneRunnerHandler.class);
    serve(GET, handlerPrefix.prefixPath("/slave/*"), SlaveResourceHandler.class);

    if (executionType == ExecutionType.STANDALONE) {
      serve(GET, handlerPrefix.prefixPath("/test/*"), CachingTestResourceHandler.class);
    } else {
      serve(GET, handlerPrefix.prefixPath("/test/*"), NonCachingTestResourceHandler.class);
    }

    serve(GET, handlerPrefix.prefixPath("/quit"), QuitHandler.class);
    serve(GET, handlerPrefix.prefixPath("/quit/*"), QuitHandler.class);
    serve(GET, handlerPrefix.prefixPath("/static/*"), StaticResourceHandler.class);
    serve(GET, handlerPrefix.prefixPath("/bcr"), BrowserControlledRunnerHandler.class);
    serve(GET, handlerPrefix.prefixPath("/bcr/*"), BrowserControlledRunnerHandler.class);

    // Constant bindings
    bindConstant()
        .annotatedWith(BaseResourceLocation.class)
        .to(SlaveResourceService.RESOURCE_LOCATION);
    bindConstant().annotatedWith(BrowserTimeout.class).to(browserTimeout);

    // Miscellaneous bindings
    bind(CapturedBrowsers.class).toInstance(capturedBrowsers);
    bind(JstdTestCaseStore.class).toInstance(testCaseStore);
    bind(new Key<ConcurrentMap<SlaveBrowser, List<String>>>() {})
        .toInstance(new ConcurrentHashMap<SlaveBrowser, List<String>>());
    bind(new Key<ConcurrentMap<SlaveBrowser, Thread>>() {})
        .toInstance(new ConcurrentHashMap<SlaveBrowser, Thread>());
    bind(new Key<Set<FileInfo>>() {}).toInstance(new HashSet<FileInfo>());
    bind(StandaloneRunnerFilesFilter.class).to(StandaloneRunnerFilesFilterImpl.class);
    bind(HandlerPathPrefix.class).toInstance(handlerPrefix);
    bind(Time.class).to(TimeImpl.class);
    bind(Boolean.class).annotatedWith(Names.named("debug")).toInstance(debug);
    bind(new TypeLiteral<Set<FileInfoScheme>>() {}).toInstance(schemes);

    bind(ExecutionType.class).toInstance(executionType);

    MapBinder<PageType, Page> pageBinder = newMapBinder(binder(), PageType.class, Page.class);
    pageBinder.addBinding(CONSOLE).to(ConsolePage.class).in(RequestScoped.class);
    pageBinder.addBinding(HEARTBEAT).to(HeartbeatPage.class).in(RequestScoped.class);
    pageBinder.addBinding(RUNNER).to(RunnerPage.class).in(RequestScoped.class);
    pageBinder.addBinding(STANDALONE_RUNNER).to(StandaloneRunnerPage.class).in(RequestScoped.class);
    pageBinder
        .addBinding(VISUAL_STANDALONE_RUNNER)
        .to(BrowserControlledRunnerPage.class)
        .in(RequestScoped.class);
  }
示例#9
0
  /** {@inheritDoc} */
  @Override
  protected void configure() {
    bind(AuthorizationService.class).to(AuthorizationServiceImpl.class);
    bind(new TypeLiteral<OAuth2RequestFactory<Request>>() {}).to(RestletOAuth2RequestFactory.class);
    bind(ResourceOwnerConsentVerifier.class).to(OpenIdResourceOwnerConsentVerifier.class);
    bind(ClientRegistrationStore.class).to(OpenAMClientRegistrationStore.class);
    bind(OpenIdConnectClientRegistrationStore.class).to(OpenAMClientRegistrationStore.class);
    bind(OAuth2ProviderSettingsFactory.class).to(OpenAMOAuth2ProviderSettingsFactory.class);
    bind(ResourceOwnerSessionValidator.class).to(OpenAMResourceOwnerSessionValidator.class);
    bind(ClientAuthenticator.class).to(ClientAuthenticatorImpl.class);
    bind(TokenStore.class).to(OpenAMTokenStore.class);
    bind(OpenIdConnectTokenStore.class).to(OpenAMTokenStore.class);
    bind(AccessTokenService.class).to(AccessTokenServiceImpl.class);
    bind(ResourceOwnerAuthenticator.class).to(OpenAMResourceOwnerAuthenticator.class);
    bind(UserInfoService.class).to(UserInfoServiceImpl.class);
    bind(TokenInfoService.class).to(TokenInfoServiceImpl.class);
    bind(AccessTokenVerifier.class).to(RestletHeaderAccessTokenVerifier.class);
    bind(AccessTokenVerifier.class)
        .annotatedWith(named(HEADER))
        .to(RestletHeaderAccessTokenVerifier.class);
    bind(AccessTokenVerifier.class)
        .annotatedWith(named(FORM_BODY))
        .to(RestletFormBodyAccessTokenVerifier.class);
    bind(AccessTokenVerifier.class)
        .annotatedWith(named(QUERY_PARAM))
        .to(RestletQueryParameterAccessTokenVerifier.class);
    bind(OpenIDConnectProvider.class).to(OpenAMOpenIDConnectProvider.class);
    bind(ClientDAO.class).to(OpenAMClientDAO.class);
    bind(OpenIdConnectClientRegistrationService.class)
        .to(OpenAMOpenIdConnectClientRegistrationService.class);
    bind(OpenAMSettings.class)
        .toProvider(
            new Provider<OpenAMSettings>() {
              public OpenAMSettings get() {
                return new OpenAMSettingsImpl(
                    OAuth2Constants.OAuth2ProviderService.NAME,
                    OAuth2Constants.OAuth2ProviderService.VERSION);
              }
            });

    bind(OpenIDTokenIssuer.class).to(OpenAMOpenIdTokenIssuer.class);

    final Multibinder<AuthorizeRequestValidator> authorizeRequestValidators =
        Multibinder.newSetBinder(binder(), AuthorizeRequestValidator.class);

    authorizeRequestValidators.addBinding().to(AuthorizeRequestValidatorImpl.class);
    authorizeRequestValidators.addBinding().to(OpenIdConnectAuthorizeRequestValidator.class);

    final Multibinder<AuthorizationCodeRequestValidator> authorizationCodeRequestValidators =
        Multibinder.newSetBinder(binder(), AuthorizationCodeRequestValidator.class);
    authorizationCodeRequestValidators.addBinding().to(AuthorizationCodeRequestValidatorImpl.class);

    final Multibinder<ClientCredentialsRequestValidator> clientCredentialsRequestValidators =
        Multibinder.newSetBinder(binder(), ClientCredentialsRequestValidator.class);
    clientCredentialsRequestValidators.addBinding().to(ClientCredentialsRequestValidatorImpl.class);

    final Multibinder<PasswordCredentialsRequestValidator> passwordCredentialsRequestValidators =
        Multibinder.newSetBinder(binder(), PasswordCredentialsRequestValidator.class);
    passwordCredentialsRequestValidators
        .addBinding()
        .to(PasswordCredentialsRequestValidatorImpl.class);

    final MapBinder<String, GrantTypeHandler> grantTypeHandlers =
        MapBinder.newMapBinder(binder(), String.class, GrantTypeHandler.class);
    grantTypeHandlers.addBinding("client_credentials").to(ClientCredentialsGrantTypeHandler.class);
    grantTypeHandlers.addBinding("password").to(PasswordCredentialsGrantTypeHandler.class);
    grantTypeHandlers.addBinding("authorization_code").to(AuthorizationCodeGrantTypeHandler.class);
    grantTypeHandlers
        .addBinding(OAuth2Constants.TokenEndpoint.JWT_BEARER)
        .to(JwtBearerGrantTypeHandler.class);

    final Multibinder<AuthorizeRequestHook> authorizeRequestHooks =
        Multibinder.newSetBinder(binder(), AuthorizeRequestHook.class);
    authorizeRequestHooks.addBinding().to(LoginHintHook.class);

    final Multibinder<TokenRequestHook> tokenRequestHooks =
        Multibinder.newSetBinder(binder(), TokenRequestHook.class);
    tokenRequestHooks.addBinding().to(LoginHintHook.class);
  }