use of org.teiid.PolicyDecider in project teiid by teiid.
the class TeiidAdd method initilaizeTeiidEngine.
private void initilaizeTeiidEngine(final OperationContext context, final ModelNode operation) throws OperationFailedException {
ServiceTarget target = context.getServiceTarget();
final String nodeName = getNodeName();
Environment environment = context.getCallEnvironment();
final JBossLifeCycleListener shutdownListener = new JBossLifeCycleListener(environment);
// $NON-NLS-1$
ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(new NamedThreadFactory("Teiid Timer"));
// async thread-pool
int maxThreads = 10;
if (asInt(THREAD_COUNT_ATTRIBUTE, operation, context) != null) {
maxThreads = asInt(THREAD_COUNT_ATTRIBUTE, operation, context);
}
buildThreadService(maxThreads, target);
// translator repository
final TranslatorRepository translatorRepo = new TranslatorRepository();
ValueService<TranslatorRepository> translatorService = new ValueService<TranslatorRepository>(new org.jboss.msc.value.Value<TranslatorRepository>() {
@Override
public TranslatorRepository getValue() throws IllegalStateException, IllegalArgumentException {
return translatorRepo;
}
});
ServiceController<TranslatorRepository> service = target.addService(TeiidServiceNames.TRANSLATOR_REPO, translatorService).install();
final ConnectorManagerRepository connectorManagerRepo = buildConnectorManagerRepository(translatorRepo);
// system function tree
SystemFunctionManager systemFunctionManager = SystemMetadata.getInstance().getSystemFunctionManager();
// VDB repository
final VDBRepository vdbRepository = new VDBRepository();
vdbRepository.setSystemFunctionManager(systemFunctionManager);
if (isDefined(DATA_ROLES_REQUIRED_ELEMENT, operation, context) && asBoolean(DATA_ROLES_REQUIRED_ELEMENT, operation, context)) {
vdbRepository.setDataRolesRequired(true);
}
if (isDefined(ALLOW_ENV_FUNCTION_ELEMENT, operation, context)) {
vdbRepository.setAllowEnvFunction(asBoolean(ALLOW_ENV_FUNCTION_ELEMENT, operation, context));
} else {
vdbRepository.setAllowEnvFunction(false);
}
VDBRepositoryService vdbRepositoryService = new VDBRepositoryService(vdbRepository);
ServiceBuilder<VDBRepository> vdbRepoService = target.addService(TeiidServiceNames.VDB_REPO, vdbRepositoryService);
vdbRepoService.addDependency(TeiidServiceNames.BUFFER_MGR, BufferManager.class, vdbRepositoryService.bufferManagerInjector);
vdbRepoService.addDependency(DependencyType.OPTIONAL, TeiidServiceNames.OBJECT_REPLICATOR, ObjectReplicator.class, vdbRepositoryService.objectReplicatorInjector);
vdbRepoService.install();
// VDB Status manager
final VDBStatusCheckerExecutorService statusChecker = new VDBStatusCheckerExecutorService();
ValueService<VDBStatusChecker> statusService = new ValueService<VDBStatusChecker>(new org.jboss.msc.value.Value<VDBStatusChecker>() {
@Override
public VDBStatusChecker getValue() throws IllegalStateException, IllegalArgumentException {
return statusChecker;
}
});
ServiceBuilder<VDBStatusChecker> statusBuilder = target.addService(TeiidServiceNames.VDB_STATUS_CHECKER, statusService);
statusBuilder.addDependency(TeiidServiceNames.THREAD_POOL_SERVICE, Executor.class, statusChecker.executorInjector);
statusBuilder.addDependency(TeiidServiceNames.VDB_REPO, VDBRepository.class, statusChecker.vdbRepoInjector);
statusBuilder.install();
// $NON-NLS-1$ //$NON-NLS-2$
RelativePathService.addService(TeiidServiceNames.DATA_DIR, "teiid-data", "jboss.server.data.dir", target);
final ObjectsSerializerService serializer = new ObjectsSerializerService();
ServiceBuilder<ObjectSerializer> objectSerializerService = target.addService(TeiidServiceNames.OBJECT_SERIALIZER, serializer);
objectSerializerService.addDependency(TeiidServiceNames.DATA_DIR, String.class, serializer.getPathInjector());
objectSerializerService.install();
// Object Replicator
boolean replicatorAvailable = false;
if (isDefined(DC_STACK_ATTRIBUTE, operation, context)) {
String stack = asString(DC_STACK_ATTRIBUTE, operation, context);
replicatorAvailable = true;
JGroupsObjectReplicatorService replicatorService = new JGroupsObjectReplicatorService();
ServiceBuilder<JGroupsObjectReplicator> serviceBuilder = target.addService(TeiidServiceNames.OBJECT_REPLICATOR, replicatorService);
// $NON-NLS-1$ //$NON-NLS-2$
serviceBuilder.addDependency(JGroupsRequirement.CHANNEL_FACTORY.getServiceName(context, stack), ChannelFactory.class, replicatorService.channelFactoryInjector);
serviceBuilder.addDependency(TeiidServiceNames.THREAD_POOL_SERVICE, Executor.class, replicatorService.executorInjector);
serviceBuilder.install();
LogManager.logInfo(LogConstants.CTX_RUNTIME, IntegrationPlugin.Util.gs(IntegrationPlugin.Event.TEIID50003));
NodeTrackerService trackerService = new NodeTrackerService(nodeName, scheduler);
ServiceBuilder<NodeTracker> nodeTrackerBuilder = target.addService(TeiidServiceNames.NODE_TRACKER_SERVICE, trackerService);
// $NON-NLS-1$ //$NON-NLS-2$
nodeTrackerBuilder.addDependency(JGroupsRequirement.CHANNEL_FACTORY.getServiceName(context, stack), ChannelFactory.class, trackerService.channelFactoryInjector);
nodeTrackerBuilder.install();
} else {
// $NON-NLS-1$
LogManager.logDetail(LogConstants.CTX_RUNTIME, IntegrationPlugin.Util.getString("distributed_cache_not_enabled"));
}
// TODO: remove verbose service by moving the buffer service from runtime project
// $NON-NLS-1$ //$NON-NLS-2$
RelativePathService.addService(TeiidServiceNames.BUFFER_DIR, "teiid-buffer", "jboss.server.temp.dir", target);
BufferManagerService bufferService = buildBufferManager(context, operation);
ServiceBuilder<BufferManager> bufferServiceBuilder = target.addService(TeiidServiceNames.BUFFER_MGR, bufferService);
bufferServiceBuilder.addDependency(TeiidServiceNames.BUFFER_DIR, String.class, bufferService.pathInjector);
bufferServiceBuilder.install();
TupleBufferCacheService tupleBufferService = new TupleBufferCacheService();
ServiceBuilder<TupleBufferCache> tupleBufferBuilder = target.addService(TeiidServiceNames.TUPLE_BUFFER, tupleBufferService);
tupleBufferBuilder.addDependency(TeiidServiceNames.BUFFER_MGR, BufferManager.class, tupleBufferService.bufferMgrInjector);
tupleBufferBuilder.addDependency(replicatorAvailable ? DependencyType.REQUIRED : DependencyType.OPTIONAL, TeiidServiceNames.OBJECT_REPLICATOR, ObjectReplicator.class, tupleBufferService.replicatorInjector);
tupleBufferBuilder.install();
PolicyDecider policyDecider = null;
if (isDefined(POLICY_DECIDER_MODULE_ELEMENT, operation, context)) {
policyDecider = buildService(PolicyDecider.class, asString(POLICY_DECIDER_MODULE_ELEMENT, operation, context));
}
final AuthorizationValidator authValidator;
if (isDefined(AUTHORIZATION_VALIDATOR_MODULE_ELEMENT, operation, context)) {
authValidator = buildService(AuthorizationValidator.class, asString(AUTHORIZATION_VALIDATOR_MODULE_ELEMENT, operation, context));
} else {
DefaultAuthorizationValidator dap = new DefaultAuthorizationValidator();
dap.setPolicyDecider(policyDecider);
authValidator = dap;
}
ValueService<AuthorizationValidator> authValidatorService = new ValueService<AuthorizationValidator>(new org.jboss.msc.value.Value<AuthorizationValidator>() {
@Override
public AuthorizationValidator getValue() throws IllegalStateException, IllegalArgumentException {
return authValidator;
}
});
target.addService(TeiidServiceNames.AUTHORIZATION_VALIDATOR, authValidatorService).install();
final PreParser preParser;
if (isDefined(PREPARSER_MODULE_ELEMENT, operation, context)) {
preParser = buildService(PreParser.class, asString(PREPARSER_MODULE_ELEMENT, operation, context));
} else {
preParser = new PreParser() {
@Override
public String preParse(String command, CommandContext context) {
return command;
}
};
}
ValueService<PreParser> preParserService = new ValueService<PreParser>(new org.jboss.msc.value.Value<PreParser>() {
@Override
public PreParser getValue() throws IllegalStateException, IllegalArgumentException {
return preParser;
}
});
target.addService(TeiidServiceNames.PREPARSER, preParserService).install();
// resultset cache
boolean rsCache = true;
if (isDefined(RSC_ENABLE_ATTRIBUTE, operation, context) && !asBoolean(RSC_ENABLE_ATTRIBUTE, operation, context)) {
rsCache = false;
}
if (!isDefined(RSC_CONTAINER_NAME_ATTRIBUTE, operation, context)) {
throw new OperationFailedException(IntegrationPlugin.Util.gs(IntegrationPlugin.Event.TEIID50094));
}
// $NON-NLS-1$
String cacheName = "resultset";
if (isDefined(RSC_NAME_ATTRIBUTE, operation, context)) {
// if null; default cache will be used
cacheName = asString(RSC_NAME_ATTRIBUTE, operation, context);
}
if (rsCache) {
CacheFactoryService cfs = new CacheFactoryService();
ServiceBuilder<CacheFactory> cacheFactoryBuilder = target.addService(TeiidServiceNames.RESULTSET_CACHE_FACTORY, cfs);
String ispnName = asString(RSC_CONTAINER_NAME_ATTRIBUTE, operation, context);
cacheFactoryBuilder.addDependency(InfinispanRequirement.CONTAINER.getServiceName(context, ispnName), EmbeddedCacheManager.class, // $NON-NLS-1$
cfs.cacheContainerInjector);
cacheFactoryBuilder.install();
int maxStaleness = DQPConfiguration.DEFAULT_MAX_STALENESS_SECONDS;
if (isDefined(RSC_MAX_STALENESS_ATTRIBUTE, operation, context)) {
maxStaleness = asInt(RSC_MAX_STALENESS_ATTRIBUTE, operation, context);
}
CacheService<CachedResults> resultSetService = new CacheService<CachedResults>(cacheName, SessionAwareCache.Type.RESULTSET, maxStaleness);
ServiceBuilder<SessionAwareCache<CachedResults>> resultsCacheBuilder = target.addService(TeiidServiceNames.CACHE_RESULTSET, resultSetService);
resultsCacheBuilder.addDependency(TeiidServiceNames.TUPLE_BUFFER, TupleBufferCache.class, resultSetService.tupleBufferCacheInjector);
resultsCacheBuilder.addDependency(TeiidServiceNames.RESULTSET_CACHE_FACTORY, CacheFactory.class, resultSetService.cacheFactoryInjector);
// $NON-NLS-1$
resultsCacheBuilder.addDependency(InfinispanCacheRequirement.CACHE.getServiceName(context, ispnName, cacheName));
// $NON-NLS-1$
resultsCacheBuilder.addDependency(InfinispanCacheRequirement.CACHE.getServiceName(context, ispnName, cacheName + SessionAwareCache.REPL));
resultsCacheBuilder.install();
}
// prepared-plan cache
boolean ppCache = true;
if (isDefined(PPC_ENABLE_ATTRIBUTE, operation, context)) {
ppCache = asBoolean(PPC_ENABLE_ATTRIBUTE, operation, context);
}
if (!isDefined(PPC_CONTAINER_NAME_ATTRIBUTE, operation, context)) {
throw new OperationFailedException(IntegrationPlugin.Util.gs(IntegrationPlugin.Event.TEIID50095));
}
// $NON-NLS-1$
cacheName = "preparedplan";
if (isDefined(PPC_NAME_ATTRIBUTE, operation, context)) {
cacheName = asString(PPC_NAME_ATTRIBUTE, operation, context);
}
if (ppCache) {
CacheFactoryService cfs = new CacheFactoryService();
ServiceBuilder<CacheFactory> cacheFactoryBuilder = target.addService(TeiidServiceNames.PREPAREDPLAN_CACHE_FACTORY, cfs);
String ispnName = asString(PPC_CONTAINER_NAME_ATTRIBUTE, operation, context);
cacheFactoryBuilder.addDependency(InfinispanRequirement.CONTAINER.getServiceName(context, ispnName), EmbeddedCacheManager.class, // $NON-NLS-1$
cfs.cacheContainerInjector);
cacheFactoryBuilder.install();
CacheService<PreparedPlan> preparedPlanService = new CacheService<PreparedPlan>(cacheName, SessionAwareCache.Type.PREPAREDPLAN, 0);
ServiceBuilder<SessionAwareCache<PreparedPlan>> preparedPlanCacheBuilder = target.addService(TeiidServiceNames.CACHE_PREPAREDPLAN, preparedPlanService);
preparedPlanCacheBuilder.addDependency(TeiidServiceNames.PREPAREDPLAN_CACHE_FACTORY, CacheFactory.class, preparedPlanService.cacheFactoryInjector);
// $NON-NLS-1$
preparedPlanCacheBuilder.addDependency(InfinispanCacheRequirement.CACHE.getServiceName(context, ispnName, cacheName));
preparedPlanCacheBuilder.install();
}
// Query Engine
final DQPCoreService engine = buildQueryEngine(context, operation);
EventDistributorFactoryService edfs = new EventDistributorFactoryService();
ServiceBuilder<InternalEventDistributorFactory> edfsServiceBuilder = target.addService(TeiidServiceNames.EVENT_DISTRIBUTOR_FACTORY, edfs);
edfsServiceBuilder.addDependency(TeiidServiceNames.VDB_REPO, VDBRepository.class, edfs.vdbRepositoryInjector);
edfsServiceBuilder.addDependency(replicatorAvailable ? DependencyType.REQUIRED : DependencyType.OPTIONAL, TeiidServiceNames.OBJECT_REPLICATOR, ObjectReplicator.class, edfs.objectReplicatorInjector);
edfs.dqpCore = engine.getValue();
edfsServiceBuilder.install();
// $NON-NLS-1$
String workManager = "default";
if (isDefined(WORKMANAGER, operation, context)) {
workManager = asString(WORKMANAGER, operation, context);
}
ServiceBuilder<DQPCore> engineBuilder = target.addService(TeiidServiceNames.ENGINE, engine);
// $NON-NLS-1$ //$NON-NLS-2$
engineBuilder.addDependency(ServiceName.JBOSS.append("connector", "workmanager", workManager), WorkManager.class, engine.getWorkManagerInjector());
// $NON-NLS-1$ //$NON-NLS-2$
engineBuilder.addDependency(ServiceName.JBOSS.append("txn", "XATerminator"), XATerminator.class, engine.getXaTerminatorInjector());
// $NON-NLS-1$ //$NON-NLS-2$
engineBuilder.addDependency(ServiceName.JBOSS.append("txn", "TransactionManager"), TransactionManager.class, engine.getTxnManagerInjector());
engineBuilder.addDependency(TeiidServiceNames.BUFFER_MGR, BufferManager.class, engine.getBufferManagerInjector());
engineBuilder.addDependency(TeiidServiceNames.TRANSLATOR_REPO, TranslatorRepository.class, engine.getTranslatorRepositoryInjector());
engineBuilder.addDependency(TeiidServiceNames.VDB_REPO, VDBRepository.class, engine.getVdbRepositoryInjector());
engineBuilder.addDependency(TeiidServiceNames.AUTHORIZATION_VALIDATOR, AuthorizationValidator.class, engine.getAuthorizationValidatorInjector());
engineBuilder.addDependency(TeiidServiceNames.PREPARSER, PreParser.class, engine.getPreParserInjector());
engineBuilder.addDependency(rsCache ? DependencyType.REQUIRED : DependencyType.OPTIONAL, TeiidServiceNames.CACHE_RESULTSET, SessionAwareCache.class, engine.getResultSetCacheInjector());
engineBuilder.addDependency(TeiidServiceNames.CACHE_PREPAREDPLAN, SessionAwareCache.class, engine.getPreparedPlanCacheInjector());
engineBuilder.addDependency(TeiidServiceNames.EVENT_DISTRIBUTOR_FACTORY, InternalEventDistributorFactory.class, engine.getEventDistributorFactoryInjector());
engineBuilder.setInitialMode(ServiceController.Mode.ACTIVE);
engineBuilder.install();
// add JNDI for event distributor
final ReferenceFactoryService<EventDistributorFactory> referenceFactoryService = new ReferenceFactoryService<EventDistributorFactory>();
// $NON-NLS-1$
final ServiceName referenceFactoryServiceName = TeiidServiceNames.EVENT_DISTRIBUTOR_FACTORY.append("reference-factory");
final ServiceBuilder<?> referenceBuilder = target.addService(referenceFactoryServiceName, referenceFactoryService);
referenceBuilder.addDependency(TeiidServiceNames.EVENT_DISTRIBUTOR_FACTORY, EventDistributorFactory.class, referenceFactoryService.getInjector());
referenceBuilder.setInitialMode(ServiceController.Mode.ACTIVE);
// $NON-NLS-1$
String jndiName = "teiid/event-distributor-factory";
final ContextNames.BindInfo bindInfo = ContextNames.bindInfoFor(jndiName);
final BinderService binderService = new BinderService(bindInfo.getBindName());
final ServiceBuilder<?> binderBuilder = target.addService(bindInfo.getBinderServiceName(), binderService);
binderBuilder.addDependency(referenceFactoryServiceName, ManagedReferenceFactory.class, binderService.getManagedObjectInjector());
binderBuilder.addDependency(bindInfo.getParentContextServiceName(), ServiceBasedNamingStore.class, binderService.getNamingStoreInjector());
binderBuilder.setInitialMode(ServiceController.Mode.ACTIVE);
referenceBuilder.install();
binderBuilder.install();
// $NON-NLS-1$
LogManager.logDetail(LogConstants.CTX_RUNTIME, IntegrationPlugin.Util.getString("event_distributor_bound", jndiName));
// Materialization management service
MaterializationManagementService matviewService = new MaterializationManagementService(shutdownListener, scheduler);
ServiceBuilder<MaterializationManager> matviewBuilder = target.addService(TeiidServiceNames.MATVIEW_SERVICE, matviewService);
matviewBuilder.addDependency(TeiidServiceNames.ENGINE, DQPCore.class, matviewService.dqpInjector);
matviewBuilder.addDependency(TeiidServiceNames.VDB_REPO, VDBRepository.class, matviewService.vdbRepositoryInjector);
matviewBuilder.addDependency(replicatorAvailable ? DependencyType.REQUIRED : DependencyType.OPTIONAL, TeiidServiceNames.NODE_TRACKER_SERVICE, NodeTracker.class, matviewService.nodeTrackerInjector);
matviewBuilder.install();
// Register VDB deployer
context.addStep(new AbstractDeploymentChainStep() {
@Override
public void execute(DeploymentProcessorTarget processorTarget) {
// vdb deployers
processorTarget.addDeploymentProcessor(TeiidExtension.TEIID_SUBSYSTEM, Phase.STRUCTURE, 0, new FileRootMountProcessor(".ddl"));
processorTarget.addDeploymentProcessor(TeiidExtension.TEIID_SUBSYSTEM, Phase.STRUCTURE, Phase.STRUCTURE_WAR_DEPLOYMENT_INIT | 0xFF75, new DynamicVDBRootMountDeployer());
processorTarget.addDeploymentProcessor(TeiidExtension.TEIID_SUBSYSTEM, Phase.STRUCTURE, Phase.STRUCTURE_WAR_DEPLOYMENT_INIT | 0xFF76, new VDBStructureDeployer());
processorTarget.addDeploymentProcessor(TeiidExtension.TEIID_SUBSYSTEM, Phase.PARSE, Phase.PARSE_WEB_DEPLOYMENT | 0x0001, new VDBParserDeployer(vdbRepository));
processorTarget.addDeploymentProcessor(TeiidExtension.TEIID_SUBSYSTEM, Phase.DEPENDENCIES, Phase.DEPENDENCIES_WAR_MODULE | 0x0001, new VDBDependencyDeployer());
processorTarget.addDeploymentProcessor(TeiidExtension.TEIID_SUBSYSTEM, Phase.INSTALL, Phase.INSTALL_WAR_DEPLOYMENT | 0x1000, new VDBDeployer(translatorRepo, vdbRepository, shutdownListener));
// translator deployers
processorTarget.addDeploymentProcessor(TeiidExtension.TEIID_SUBSYSTEM, Phase.STRUCTURE, Phase.STRUCTURE_JDBC_DRIVER | 0x0001, new TranslatorStructureDeployer());
processorTarget.addDeploymentProcessor(TeiidExtension.TEIID_SUBSYSTEM, Phase.DEPENDENCIES, Phase.DEPENDENCIES_MODULE | 0x0001, new TranslatorDependencyDeployer());
processorTarget.addDeploymentProcessor(TeiidExtension.TEIID_SUBSYSTEM, Phase.INSTALL, Phase.INSTALL_JDBC_DRIVER | 0x0001, new TranslatorDeployer());
}
}, OperationContext.Stage.RUNTIME);
// install a session service
// TODO: may eventually couple this with DQPCore
final SessionServiceImpl sessionServiceImpl = new SessionServiceImpl();
if (isDefined(AUTHENTICATION_SECURITY_DOMAIN_ATTRIBUTE, operation, context)) {
String securityDomain = asString(AUTHENTICATION_SECURITY_DOMAIN_ATTRIBUTE, operation, context);
sessionServiceImpl.setSecurityDomain(securityDomain);
}
if (isDefined(AUTHENTICATION_MAX_SESSIONS_ALLOWED_ATTRIBUTE, operation, context)) {
sessionServiceImpl.setSessionMaxLimit(asLong(AUTHENTICATION_MAX_SESSIONS_ALLOWED_ATTRIBUTE, operation, context));
}
if (isDefined(AUTHENTICATION_SESSION_EXPIRATION_TIME_LIMIT_ATTRIBUTE, operation, context)) {
sessionServiceImpl.setSessionExpirationTimeLimit(asLong(AUTHENTICATION_SESSION_EXPIRATION_TIME_LIMIT_ATTRIBUTE, operation, context));
}
if (isDefined(AUTHENTICATION_TYPE_ATTRIBUTE, operation, context)) {
sessionServiceImpl.setAuthenticationType(AuthenticationType.valueOf(asString(AUTHENTICATION_TYPE_ATTRIBUTE, operation, context)));
} else {
sessionServiceImpl.setAuthenticationType(AuthenticationType.USERPASSWORD);
}
if (isDefined(AUTHENTICATION_TRUST_ALL_LOCAL_ATTRIBUTE, operation, context)) {
boolean allowUnauthenticated = asBoolean(AUTHENTICATION_TRUST_ALL_LOCAL_ATTRIBUTE, operation, context);
sessionServiceImpl.setTrustAllLocal(allowUnauthenticated);
}
if (isDefined(AUTHENTICATION_ALLOW_SECURITY_DOMAIN_QUALIFIER, operation, context)) {
boolean allowSecurityDomainQualifier = asBoolean(AUTHENTICATION_ALLOW_SECURITY_DOMAIN_QUALIFIER, operation, context);
sessionServiceImpl.setAllowSecurityDomainQualifier(allowSecurityDomainQualifier);
}
sessionServiceImpl.setDqp(engine.getValue());
sessionServiceImpl.setVDBRepository(vdbRepository);
sessionServiceImpl.setSecurityHelper(new JBossSecurityHelper());
sessionServiceImpl.start();
ContainerSessionService containerSessionService = new ContainerSessionService(sessionServiceImpl);
ServiceBuilder<SessionService> sessionServiceBuilder = target.addService(TeiidServiceNames.SESSION, containerSessionService);
sessionServiceBuilder.install();
// rest war service
RestWarGenerator warGenerator = TeiidAdd.buildService(RestWarGenerator.class, "org.jboss.teiid.rest-service");
ResteasyEnabler restEnabler = new ResteasyEnabler(warGenerator);
ServiceBuilder<Void> warGeneratorSvc = target.addService(TeiidServiceNames.REST_WAR_SERVICE, restEnabler);
warGeneratorSvc.addDependency(Services.JBOSS_SERVER_CONTROLLER, ModelController.class, restEnabler.controllerValue);
warGeneratorSvc.addDependency(TeiidServiceNames.THREAD_POOL_SERVICE, Executor.class, restEnabler.executorInjector);
warGeneratorSvc.addDependency(TeiidServiceNames.VDB_REPO, VDBRepository.class, restEnabler.vdbRepoInjector);
warGeneratorSvc.install();
}
Aggregations