org.glassfish.hk2.utilities.ServiceLocatorUtilities Java Examples

@Test
public void backstopperOnlyExceptionMapperFactory_removes_all_exception_mappers_except_Jersey2ApiExceptionHandler()
    throws NoSuchFieldException, IllegalAccessException {
    // given
    AbstractBinder lotsOfExceptionMappersBinder = new AbstractBinder() {
        @Override
        protected void configure() {
            bind(JsonMappingExceptionMapper.class).to(ExceptionMapper.class).in(Singleton.class);
            bind(JsonParseExceptionMapper.class).to(ExceptionMapper.class).in(Singleton.class);
            bind(generateJerseyApiExceptionHandler(projectApiErrors, utils)).to(ExceptionMapper.class);
        }
    };

    ServiceLocator locator = ServiceLocatorUtilities.bind(lotsOfExceptionMappersBinder);

    // when
    BackstopperOnlyExceptionMapperFactory overrideExceptionMapper = new BackstopperOnlyExceptionMapperFactory(locator);

    // then
    Set<Object> emTypesLeft = overrideExceptionMapper.getFieldObj(
        ExceptionMapperFactory.class, overrideExceptionMapper, "exceptionMapperTypes"
    );
    assertThat(emTypesLeft).hasSize(1);
    ServiceHandle serviceHandle = overrideExceptionMapper.getFieldObj(emTypesLeft.iterator().next(), "mapper");
    assertThat(serviceHandle.getService()).isInstanceOf(Jersey2ApiExceptionHandler.class);
}
 

public Component() {
  this.locator = ServiceLocatorUtilities.createAndPopulateServiceLocator();
  ServiceLocatorUtilities.addOneConstant(this.locator, this);

  // Optionally remove existing handlers attached to j.u.l root logger
  SLF4JBridgeHandler.removeHandlersForRootLogger();

  // add SLF4JBridgeHandler to java.util.logging's root logger
  SLF4JBridgeHandler.install();
}
 

@Test
public void exceptionMapperFactoryOverrideBinder_configures_ExceptionMappers_override() {
    // given
    AbstractBinder defaultJersey2ExceptionMapperBinder = new ExceptionMapperFactory.Binder();
    ExceptionMapperFactoryOverrideBinder overrideBinder =  new ExceptionMapperFactoryOverrideBinder();
    ServiceLocator locator = ServiceLocatorUtilities.bind(defaultJersey2ExceptionMapperBinder, overrideBinder);

    // when
    ExceptionMappers result = locator.getService(ExceptionMappers.class);

    // then
    assertThat(result).isInstanceOf(BackstopperOnlyExceptionMapperFactory.class);
}
 

/**
 * {@inheritDoc}
 */
@Override
public void setup(final Application application) {

    final Set<ClassInfo> classInfoSet = Sets.newLinkedHashSet();
    subscribeSystemEvent(ClassFoundEvent.class, event -> event.accept(info -> {
        if (info.containsAnnotations(Service.class)) {
            classInfoSet.add(info);
            return true;
        }
        return false;
    }));

    final Feature localResource = new Feature() {

        @Inject
        private ServiceLocator locator;

        @Override
        public boolean configure(FeatureContext context) {
            for (ClassInfo classInfo : classInfoSet) {
                ServiceLocatorUtilities.addClasses(locator, classInfo.toClass());
            }
            classInfoSet.clear();
            return true;
        }
    };

    application.register(localResource);
}
 

private void bindFlyway(final String name, final Flyway flyway) {
    ServiceLocatorUtilities.bind(locator, new AbstractBinder() {
        @Override
        protected void configure() {
            bind(flyway).to(Flyway.class).named(name).proxy(false);
            if (name.equals(DataSourceManager.getDefaultDataSourceName())) {
                bind(flyway).to(Flyway.class).proxy(false);
            }
        }
    });
}
 

public static void main(String[] args) throws InterruptedException,
    IOException {
  PropertyConfigurator.configure(ClassLoader.getSystemResource("log4j.properties"));

  final SubmarineConfiguration conf = SubmarineConfiguration.getInstance();
  LOG.info("Submarine server Host: " + conf.getServerAddress());
  if (conf.useSsl() == false) {
    LOG.info("Submarine server Port: " + conf.getServerPort());
  } else {
    LOG.info("Submarine server SSL Port: " + conf.getServerSslPort());
  }

  jettyWebServer = setupJettyServer(conf);

  // Web UI
  HandlerList handlers = new HandlerList();
  webApp = setupWebAppContext(handlers, conf);
  jettyWebServer.setHandler(handlers);

  // Add
  sharedServiceLocator = ServiceLocatorFactory.getInstance().create("shared-locator");
  ServiceLocatorUtilities.enableImmediateScope(sharedServiceLocator);
  ServiceLocatorUtilities.bind(
      sharedServiceLocator,
      new AbstractBinder() {
        @Override
        protected void configure() {
          bindAsContract(NotebookServer.class)
              .to(WebSocketServlet.class)
              .in(Singleton.class);
        }
      });

  setupRestApiContextHandler(webApp, conf);

  // Notebook server
  setupNotebookServer(webApp, conf, sharedServiceLocator);

  // Cluster Server
  setupClusterServer();

  rpcServer = SubmarineRpcServer.startRpcServer();
  startServer();
}
 

@Override
public void run(ServerConfiguration configuration, Environment environment) throws Exception {

    final DBIFactory factory = new DBIFactory();
    final DBI jdbi = factory.build(environment, configuration.getDataSourceFactory(), "sapData");

    ObjectMapper objectMapper = environment.getObjectMapper();
    SapConfiguration sapConfiguration = configuration.getSapConfig();
    JobConfiguration jobConfiguration = configuration.getJobConfig();
    NiPingServiceBinder niPingServiceBinder = new NiPingServiceBinder(jdbi, objectMapper, sapConfiguration, jobConfiguration);

    ServiceLocator serviceLocator = ServiceLocatorUtilities.bind(niPingServiceBinder);
    SapBasicAuthenticator sapBasicAuthenticator = ServiceLocatorUtilities.getService(serviceLocator, SapBasicAuthenticator.class
            .getName());
    SapOAuthenticator sapOAuthenticator = ServiceLocatorUtilities.getService(serviceLocator, SapOAuthenticator.class.getName());

    final BasicCredentialAuthFilter basicAuthFilter = new BasicCredentialAuthFilter.Builder<BasicAuthUser>()
            .setAuthenticator(sapBasicAuthenticator)
            .buildAuthFilter();
    final AuthFilter oAuthFilter = new OAuthCredentialAuthFilter.Builder<OAuthUser>()
            .setAuthenticator(sapOAuthenticator)
            .setPrefix("Bearer")
            .buildAuthFilter();

    final PolymorphicAuthDynamicFeature feature = new PolymorphicAuthDynamicFeature<UserPrincipal>(ImmutableMap.of(BasicAuthUser
            .class, basicAuthFilter, OAuthUser.class, oAuthFilter));
    final AbstractBinder binder = new PolymorphicAuthValueFactoryProvider.Binder<>(ImmutableSet.of(BasicAuthUser.class, OAuthUser
            .class));
    environment.jersey().register(new AuthFilterDynamicBinding());
    environment.jersey().register(feature);
    environment.jersey().register(binder);

    environment.jersey().register(niPingServiceBinder);
    environment.jersey().packages("com.cloudwise.sap.niping.auth");
    environment.jersey().packages("com.cloudwise.sap.niping.service");
    environment.jersey().packages("com.cloudwise.sap.niping.dao");
    environment.jersey().packages("com.cloudwise.sap.niping.common.vo.converter");
    environment.jersey().packages("com.cloudwise.sap.niping.resource");

    environment.jersey().register(SessionFactoryProvider.class);
    environment.servlets().setSessionHandler(new SessionHandler());
}