use of org.teiid.dqp.internal.process.DQPCore in project teiid by teiid.
the class EngineStatistics method executeQuery.
public static ModelNode executeQuery(final VDBMetaData vdb, final DQPCore engine, final String command, final long timoutInMilli, final ModelNode resultsNode, final boolean timeAsString) throws OperationFailedException {
// $NON-NLS-1$
String user = "CLI ADMIN";
// $NON-NLS-1$
LogManager.logDetail(LogConstants.CTX_RUNTIME, IntegrationPlugin.Util.getString("admin_executing", user, command));
try {
Future<?> f = DQPCore.executeQuery(command, vdb, user, "admin-console", timoutInMilli, engine, new // $NON-NLS-1$
DQPCore.ResultsListener() {
@Override
public void onResults(List<String> columns, List<? extends List<?>> results) throws Exception {
writeResults(resultsNode, columns, results, timeAsString);
}
});
f.get();
} catch (Throwable e) {
throw new OperationFailedException(e);
}
return resultsNode;
}
use of org.teiid.dqp.internal.process.DQPCore 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