io.quarkus.arc.runtime.BeanContainer Java Examples

public VertxRequestHandler(Vertx vertx,
        BeanContainer beanContainer,
        String rootPath,
        Executor executor) {
    this.vertx = vertx;
    this.beanContainer = beanContainer;
    // make sure rootPath ends with "/" for easy parsing
    if (rootPath == null) {
        this.rootPath = "/";
    } else if (!rootPath.endsWith("/")) {
        this.rootPath = rootPath + "/";
    } else {
        this.rootPath = rootPath;
    }

    this.executor = executor;
    Instance<CurrentIdentityAssociation> association = CDI.current().select(CurrentIdentityAssociation.class);
    this.association = association.isResolvable() ? association.get() : null;
    currentVertxRequest = CDI.current().select(CurrentVertxRequest.class).get();
}
 

public RuntimeValue<ServletInfo> registerServlet(RuntimeValue<DeploymentInfo> deploymentInfo,
        String name,
        Class<?> servletClass,
        boolean asyncSupported,
        int loadOnStartup,
        BeanContainer beanContainer,
        InstanceFactory<? extends Servlet> instanceFactory) throws Exception {

    InstanceFactory<? extends Servlet> factory = instanceFactory != null ? instanceFactory
            : new QuarkusInstanceFactory(beanContainer.instanceFactory(servletClass));
    ServletInfo servletInfo = new ServletInfo(name, (Class<? extends Servlet>) servletClass,
            factory);
    deploymentInfo.getValue().addServlet(servletInfo);
    servletInfo.setAsyncSupported(asyncSupported);
    if (loadOnStartup > 0) {
        servletInfo.setLoadOnStartup(loadOnStartup);
    }
    return new RuntimeValue<>(servletInfo);
}
 

public void buildCaches(boolean managedExecutorInitialized, BeanContainer beanContainer,
        Set<CaffeineCacheInfo> cacheInfos) {
    // The number of caches is known at build time so we can use fixed initialCapacity and loadFactor for the caches map.
    Map<String, CaffeineCache> caches = new HashMap<>(cacheInfos.size() + 1, 1.0F);

    ManagedExecutor managedExecutor = null;
    if (managedExecutorInitialized) {
        managedExecutor = beanContainer.instance(ManagedExecutor.class);
    }

    for (CaffeineCacheInfo cacheInfo : cacheInfos) {
        if (LOGGER.isDebugEnabled()) {
            LOGGER.debugf(
                    "Building Caffeine cache [%s] with [initialCapacity=%s], [maximumSize=%s], [expireAfterWrite=%s] and [expireAfterAccess=%s]",
                    cacheInfo.name, cacheInfo.initialCapacity, cacheInfo.maximumSize, cacheInfo.expireAfterWrite,
                    cacheInfo.expireAfterAccess);
        }
        CaffeineCache cache = new CaffeineCache(cacheInfo, managedExecutor);
        caches.put(cacheInfo.name, cache);
    }

    beanContainer.instance(CacheRepository.class).setCaches(caches);
}
 

public VertxRequestHandler(Vertx vertx,
        BeanContainer beanContainer,
        ResteasyDeployment deployment,
        String rootPath,
        BufferAllocator allocator, Executor executor, long readTimeout) {
    this.vertx = vertx;
    this.beanContainer = beanContainer;
    this.dispatcher = new RequestDispatcher((SynchronousDispatcher) deployment.getDispatcher(),
            deployment.getProviderFactory(), null, Thread.currentThread().getContextClassLoader());
    this.rootPath = rootPath;
    this.allocator = allocator;
    this.executor = executor;
    this.readTimeout = readTimeout;
    Instance<CurrentIdentityAssociation> association = CDI.current().select(CurrentIdentityAssociation.class);
    this.association = association.isResolvable() ? association.get() : null;
    currentVertxRequest = CDI.current().select(CurrentVertxRequest.class).get();
}
 

public VertxRequestHandler(Vertx vertx,
        BeanContainer beanContainer,
        ObjectMapper mapper,
        FunqyKnativeEventsConfig config,
        FunctionInvoker defaultInvoker,
        Map<String, FunctionInvoker> typeTriggers,
        Executor executor) {
    this.defaultInvoker = defaultInvoker;
    this.vertx = vertx;
    this.beanContainer = beanContainer;
    this.executor = executor;
    this.mapper = mapper;
    this.typeTriggers = typeTriggers;
    Instance<CurrentIdentityAssociation> association = CDI.current().select(CurrentIdentityAssociation.class);
    this.association = association.isResolvable() ? association.get() : null;
    Instance<IdentityProviderManager> identityProviderManager = CDI.current().select(IdentityProviderManager.class);
    this.currentVertxRequest = CDI.current().select(CurrentVertxRequest.class).get();

}
 

public Handler<RoutingContext> start(String contextPath,
        Supplier<Vertx> vertx,
        ShutdownContext shutdown,
        BeanContainer beanContainer,
        Executor executor) {

    shutdown.addShutdownTask(new Runnable() {
        @Override
        public void run() {
            FunctionConstructor.CONTAINER = null;
            objectMapper = null;
        }
    });
    FunctionConstructor.CONTAINER = beanContainer;

    return new VertxRequestHandler(vertx.get(), beanContainer, contextPath, executor);
}
 

public RuntimeValue<SqsAsyncClient> buildAsyncClient(RuntimeValue<? extends AwsClientBuilder> builder,
        BeanContainer beanContainer,
        ShutdownContext shutdown) {
    SqsClientProducer producer = beanContainer.instance(SqsClientProducer.class);
    producer.setAsyncConfiguredBuilder((SqsAsyncClientBuilder) builder.getValue());
    shutdown.addShutdownTask(producer::destroy);
    return new RuntimeValue<>(producer.asyncClient());
}
 

public RuntimeValue<KmsClient> buildClient(RuntimeValue<? extends AwsClientBuilder> builder,
        BeanContainer beanContainer,
        ShutdownContext shutdown) {
    KmsClientProducer producer = beanContainer.instance(KmsClientProducer.class);
    producer.setSyncConfiguredBuilder((KmsClientBuilder) builder.getValue());
    shutdown.addShutdownTask(producer::destroy);
    return new RuntimeValue<>(producer.client());
}
 

public RuntimeValue<CamelRuntime> createRuntime(BeanContainer beanContainer, RuntimeValue<CamelMain> main) {
    final CamelRuntime runtime = new CamelMainRuntime(main.getValue());

    // register to the container
    beanContainer.instance(CamelProducers.class).setRuntime(runtime);

    return new RuntimeValue<>(runtime);
}
 

public RuntimeValue<SnsClient> buildClient(RuntimeValue<? extends AwsClientBuilder> builder,
        BeanContainer beanContainer,
        ShutdownContext shutdown) {
    SnsClientProducer producer = beanContainer.instance(SnsClientProducer.class);
    producer.setSyncConfiguredBuilder((SnsClientBuilder) builder.getValue());
    shutdown.addShutdownTask(producer::destroy);
    return new RuntimeValue<>(producer.client());
}
 

public RuntimeValue<SesAsyncClient> buildAsyncClient(RuntimeValue<? extends AwsClientBuilder> builder,
        BeanContainer beanContainer,
        ShutdownContext shutdown) {
    SesClientProducer producer = beanContainer.instance(SesClientProducer.class);
    producer.setAsyncConfiguredBuilder((SesAsyncClientBuilder) builder.getValue());
    shutdown.addShutdownTask(producer::destroy);
    return new RuntimeValue<>(producer.asyncClient());
}
 

public RuntimeValue<SesClient> buildClient(RuntimeValue<? extends AwsClientBuilder> builder,
        BeanContainer beanContainer,
        ShutdownContext shutdown) {
    SesClientProducer producer = beanContainer.instance(SesClientProducer.class);
    producer.setSyncConfiguredBuilder((SesClientBuilder) builder.getValue());
    shutdown.addShutdownTask(producer::destroy);
    return new RuntimeValue<>(producer.client());
}
 

public RuntimeValue<KmsAsyncClient> buildAsyncClient(RuntimeValue<? extends AwsClientBuilder> builder,
        BeanContainer beanContainer,
        ShutdownContext shutdown) {
    KmsClientProducer producer = beanContainer.instance(KmsClientProducer.class);
    producer.setAsyncConfiguredBuilder((KmsAsyncClientBuilder) builder.getValue());
    shutdown.addShutdownTask(producer::destroy);
    return new RuntimeValue<>(producer.asyncClient());
}
 

public RuntimeValue<SqsClient> buildClient(RuntimeValue<? extends AwsClientBuilder> builder,
        BeanContainer beanContainer,
        ShutdownContext shutdown) {
    SqsClientProducer producer = beanContainer.instance(SqsClientProducer.class);
    producer.setSyncConfiguredBuilder((SqsClientBuilder) builder.getValue());
    shutdown.addShutdownTask(producer::destroy);
    return new RuntimeValue<>(producer.client());
}
 

public RuntimeValue<DynamoDbClient> buildClient(RuntimeValue<? extends AwsClientBuilder> builder,
        BeanContainer beanContainer,
        ShutdownContext shutdown) {
    DynamodbClientProducer producer = beanContainer.instance(DynamodbClientProducer.class);
    producer.setSyncConfiguredBuilder((DynamoDbClientBuilder) builder.getValue());
    shutdown.addShutdownTask(producer::destroy);
    return new RuntimeValue<>(producer.client());
}
 

public RuntimeValue<DynamoDbAsyncClient> buildAsyncClient(RuntimeValue<? extends AwsClientBuilder> builder,
        BeanContainer beanContainer,
        ShutdownContext shutdown) {
    DynamodbClientProducer producer = beanContainer.instance(DynamodbClientProducer.class);
    producer.setAsyncConfiguredBuilder((DynamoDbAsyncClientBuilder) builder.getValue());
    shutdown.addShutdownTask(producer::destroy);
    return new RuntimeValue<>(producer.asyncClient());
}
 

public RuntimeValue<S3Client> buildClient(RuntimeValue<? extends AwsClientBuilder> builder,
        BeanContainer beanContainer,
        ShutdownContext shutdown) {
    S3ClientProducer producer = beanContainer.instance(S3ClientProducer.class);
    producer.setSyncConfiguredBuilder((S3ClientBuilder) builder.getValue());
    shutdown.addShutdownTask(producer::destroy);
    return new RuntimeValue<>(producer.client());
}
 

public RuntimeValue<S3AsyncClient> buildAsyncClient(RuntimeValue<? extends AwsClientBuilder> builder,
        BeanContainer beanContainer,
        ShutdownContext shutdown) {
    S3ClientProducer producer = beanContainer.instance(S3ClientProducer.class);
    producer.setAsyncConfiguredBuilder((S3AsyncClientBuilder) builder.getValue());
    shutdown.addShutdownTask(producer::destroy);
    return new RuntimeValue<>(producer.asyncClient());
}
 

public void setHandlerClass(Class<? extends RequestHandler<?, ?>> handler, BeanContainer container) {
    handlerClass = handler;
    beanContainer = container;
    ObjectMapper objectMapper = AmazonLambdaMapperRecorder.objectMapper;
    Method handlerMethod = discoverHandlerMethod(handlerClass);
    objectReader = objectMapper.readerFor(handlerMethod.getParameterTypes()[0]);
    objectWriter = objectMapper.writerFor(handlerMethod.getReturnType());
}
 

public BeanContainerListener configure(Properties properties) {
    return new BeanContainerListener() {

        @Override
        public void created(BeanContainer container) {
            KafkaStreamsTopologyManager instance = container.instance(KafkaStreamsTopologyManager.class);
            instance.configure(properties);
        }
    };
}
 

public BeanContainerListener configureDataSource() {
    return new BeanContainerListener() {
        @Override
        public void created(BeanContainer container) {
            String driver = CONFIG.getRawValue("quarkus.datasource.driver");
            DataSourceSupport instance = container.instance(DataSourceSupport.class);
            DataSourceSupport.Entry entry = instance.entries.get(DataSourceUtil.DEFAULT_DATASOURCE_NAME);
            entry.resolvedDriverClass = driver;
        }
    };
}
 

public RuntimeValue<SnsAsyncClient> buildAsyncClient(RuntimeValue<? extends AwsClientBuilder> builder,
        BeanContainer beanContainer,
        ShutdownContext shutdown) {
    SnsClientProducer producer = beanContainer.instance(SnsClientProducer.class);
    producer.setAsyncConfiguredBuilder((SnsAsyncClientBuilder) builder.getValue());
    shutdown.addShutdownTask(producer::destroy);
    return new RuntimeValue<>(producer.asyncClient());
}
 

public void configureRuntime(BeanContainer container, ExecutorService executorService) {
    // associate the static init manager to the runtime CL
    ContextManagerProvider contextManagerProvider = ContextManagerProvider.instance();
    // finish building our manager
    builder.withDefaultExecutorService(executorService);

    SmallRyeContextManager contextManager = builder.build();

    contextManagerProvider.registerContextManager(contextManager, Thread.currentThread().getContextClassLoader());

    // initialise injection
    SmallRyeContextPropagationProvider cpProvider = container.instance(SmallRyeContextPropagationProvider.class);
    cpProvider.initialize(executorService);
}
 

public RuntimeValue<InjectorFactory> setup(BeanContainer container, List<Function<Object, Object>> propertyUnwrappers) {
    QuarkusInjectorFactory.CONTAINER = container;
    QuarkusInjectorFactory.PROXY_UNWRAPPER = new Function<Object, Object>() {
        @Override
        public Object apply(Object o) {
            Object res = o;
            for (Function<Object, Object> i : propertyUnwrappers) {
                res = i.apply(res);
            }
            return res;
        }
    };
    return new RuntimeValue<>(new QuarkusInjectorFactory());
}
 

public BeanContainerListener hackAroundExtension() {
    return new BeanContainerListener() {
        @Override
        public void created(BeanContainer container) {
            try {
                Field f = RestClientExtension.class.getDeclaredField("manager");
                f.setAccessible(true);
                f.set(null, CDI.current().getBeanManager());
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
    };
}
 

@Override
public InstanceHandle<T> createInstance() throws InstantiationException {
    BeanContainer.Instance<T> instance = factory.create();
    return new InstanceHandle<T>() {
        @Override
        public T getInstance() {
            return instance.get();
        }

        @Override
        public void release() {
            instance.close();
        }
    };
}
 

public RuntimeValue<FilterInfo> registerFilter(RuntimeValue<DeploymentInfo> info,
        String name, Class<?> filterClass,
        boolean asyncSupported,
        BeanContainer beanContainer,
        InstanceFactory<? extends Filter> instanceFactory) throws Exception {

    InstanceFactory<? extends Filter> factory = instanceFactory != null ? instanceFactory
            : new QuarkusInstanceFactory(beanContainer.instanceFactory(filterClass));
    FilterInfo filterInfo = new FilterInfo(name, (Class<? extends Filter>) filterClass, factory);
    info.getValue().addFilter(filterInfo);
    filterInfo.setAsyncSupported(asyncSupported);
    return new RuntimeValue<>(filterInfo);
}
 

public BeanContainerListener initPermissions(HttpBuildTimeConfig permissions,
        Map<String, Supplier<HttpSecurityPolicy>> policies) {
    return new BeanContainerListener() {
        @Override
        public void created(BeanContainer container) {
            container.instance(PathMatchingHttpSecurityPolicy.class).init(permissions, policies);
        }
    };
}
 

public void createRegistries(BeanContainer container) {
    MetricRegistries.get(MetricRegistry.Type.APPLICATION);
    MetricRegistries.get(MetricRegistry.Type.BASE);
    MetricRegistries.get(MetricRegistry.Type.VENDOR);

    //HACK: registration is done via statics, but cleanup is done via pre destroy
    //however if the bean is not used it will not be created, so no cleanup will be done
    //we force bean creation here to make sure the container can restart correctly
    container.instance(MetricRegistries.class).getApplicationRegistry();
}
 

public void setup(OidcConfig oidcConfig, KeycloakPolicyEnforcerConfig config, BeanContainer beanContainer,
        HttpConfiguration httpConfiguration) {
    if (oidcConfig.defaultTenant.applicationType == OidcTenantConfig.ApplicationType.WEB_APP) {
        throw new OIDCException("Application type [" + oidcConfig.defaultTenant.applicationType + "] is not supported");
    }
    beanContainer.instance(KeycloakPolicyEnforcerAuthorizer.class).init(oidcConfig, config, httpConfiguration);
}