@Override
public <T> T getBusinessObject(SessionContext ctx, Class<T> businessInterface)
throws IllegalStateException {
if (businessInterface == null) {
throw new IllegalStateException("Business interface type cannot be null");
}
final Serializable sessionId =
((SessionBeanComponentInstance.SessionBeanComponentInstanceContext) ctx).getId();
if (viewServices.containsKey(businessInterface.getName())) {
final ServiceController<?> serviceController =
CurrentServiceRegistry.getServiceRegistry()
.getRequiredService(viewServices.get(businessInterface.getName()));
final ComponentView view = (ComponentView) serviceController.getValue();
final ComponentViewInstance instance;
if (sessionId != null) {
instance =
view.createInstance(
Collections.<Object, Object>singletonMap(
StatefulSessionComponent.SESSION_ATTACH_KEY, sessionId));
} else {
instance = view.createInstance();
}
return (T) instance.createProxy();
} else {
throw new IllegalStateException(
"View of type " + businessInterface + " not found on bean " + this);
}
}
public void stop(final StopContext stopContext) {
final ServiceController<?> serviceController =
stopContext
.getController()
.getServiceContainer()
.getService(CommonDeploymentService.getServiceName(jndiName));
if (serviceController != null) {
serviceController.setMode(ServiceController.Mode.REMOVE);
}
ExecutorService executorService = executor.getValue();
Runnable r =
new Runnable() {
@Override
public void run() {
try {
stopService();
} finally {
stopContext.complete();
}
}
};
try {
executorService.execute(r);
} catch (RejectedExecutionException e) {
r.run();
} finally {
stopContext.asynchronous();
}
}
/**
* @see org.jboss.wsf.spi.ioc.IoCContainerProxy#getBean(java.lang.String, java.lang.Class)
* @param <T> bean type
* @param beanName bean name inside IoC registry
* @param clazz bean type class
* @return bean instance
* @throws IllegalArgumentException if bean is not found
*/
@SuppressWarnings("unchecked")
public <T> T getBean(final String beanName, final Class<T> clazz) {
ServiceController<T> service =
(ServiceController<T>)
WSServices.getContainerRegistry().getService(ServiceName.parse(beanName));
return service != null ? service.getValue() : null;
}
/**
* Test configuration
*
* @throws Throwable Thrown if case of an error
*/
@Test
public void testRegistryConfiguration() throws Throwable {
ServiceController<?> controller =
serviceContainer.getService(ConnectorServices.RA_REPOSITORY_SERVICE);
assertNotNull(controller);
ResourceAdapterRepository repository = (ResourceAdapterRepository) controller.getValue();
assertNotNull(repository);
Set<String> ids = repository.getResourceAdapters(javax.jms.MessageListener.class);
assertNotNull(ids);
int pureInflowListener = 0;
for (String id : ids) {
if (id.indexOf("PureInflow") != -1) {
pureInflowListener++;
}
}
assertEquals(1, pureInflowListener);
String piId = ids.iterator().next();
assertNotNull(piId);
Endpoint endpoint = repository.getEndpoint(piId);
assertNotNull(endpoint);
List<MessageListener> listeners = repository.getMessageListeners(piId);
assertNotNull(listeners);
assertEquals(1, listeners.size());
MessageListener listener = listeners.get(0);
ActivationSpec as = listener.getActivation().createInstance();
assertNotNull(as);
assertNotNull(as.getResourceAdapter());
}
/*
* In order to test this specific scenario, we use Byteman to insert a monitor in the specific moment
* where the transition from STOP_REQUESTED to the next state is going to occur.
* This monitor will force the thread to wait until upperCount is incremented to 1.
*/
@Test
public void test() throws Exception {
ServiceName serviceName = ServiceName.of("service");
TestServiceListener serviceListener = new TestServiceListener();
// install service as usual
Future<ServiceController<?>> serviceStart = serviceListener.expectServiceStart(serviceName);
serviceContainer.addService(serviceName, Service.NULL).addListener(serviceListener).install();
ServiceController<?> serviceController = assertController(serviceName, serviceStart);
Future<ServiceController<?>> serviceStopping =
serviceListener.expectNoServiceStopping(serviceName);
Future<ServiceController<?>> serviceStop = serviceListener.expectNoServiceStop(serviceName);
serviceStart = serviceListener.expectNoServiceStart(serviceName);
// set the mode to NEVER, so that serviceController enters STOP_REQUESTED state
serviceController.setMode(ServiceController.Mode.NEVER);
// set the mode to ACTIVE, so that serviceController transitions to UP state
serviceController.setMode(ServiceController.Mode.ACTIVE);
// no notifications are expected
assertNull(serviceStop.get());
assertNull(serviceStopping.get());
assertNull(serviceStart.get());
// service should still be in the up state
assertSame(ServiceController.State.UP, serviceController.getState());
}
@Override
public void execute(OperationContext context, ModelNode operation)
throws OperationFailedException {
ModelNode newValue = operation.require(CacheContainerResource.PROTO_URL.getName());
String urlString = newValue.asString();
final PathAddress address = PathAddress.pathAddress(operation.require(OP_ADDR));
final String cacheContainerName = address.getElement(address.size() - 1).getValue();
final ServiceController<?> controller =
context
.getServiceRegistry(false)
.getService(EmbeddedCacheManagerService.getServiceName(cacheContainerName));
EmbeddedCacheManager cacheManager = (EmbeddedCacheManager) controller.getValue();
ProtobufMetadataManager protoManager =
cacheManager.getGlobalComponentRegistry().getComponent(ProtobufMetadataManager.class);
if (protoManager != null) {
try {
URL url = new URL(urlString);
protoManager.registerProtofile(url.openStream());
} catch (Exception e) {
throw new OperationFailedException(
new ModelNode().set(MESSAGES.failedToInvokeOperation(e.getLocalizedMessage())));
}
}
context.stepCompleted();
}
@Override
public synchronized Reference getInstance(final String className) {
Reference instance = cache.get(className);
if (instance != null) return instance;
if (!className.equals(endpointClass)) {
// handle JAXWS handler instantiation
final ServiceName handlerComponentName = getHandlerComponentServiceName(className);
final ServiceController<BasicComponent> handlerComponentController =
getComponentController(handlerComponentName);
if (handlerComponentController != null) {
// we support initialization only on non system JAXWS handlers
final BasicComponent handlerComponent = handlerComponentController.getValue();
final ComponentInstance handlerComponentInstance =
handlerComponent.createInstance(delegate.getInstance(className).getValue());
final Object handlerInstance = handlerComponentInstance.getInstance();
// mark reference as initialized because JBoss server initialized it
final Reference handlerReference =
ReferenceFactory.newInitializedReference(handlerInstance);
return cacheAndGet(handlerReference);
}
}
// fallback for system JAXWS handlers
final Reference fallbackInstance = delegate.getInstance(className);
final Reference fallbackReference =
ReferenceFactory.newUninitializedReference(fallbackInstance);
return cacheAndGet(fallbackReference);
}
public ModelController createController(final ModelNode model, final Setup registration)
throws InterruptedException {
final ServiceController<?> existingController =
serviceContainer.getService(ServiceName.of("ModelController"));
if (existingController != null) {
final CountDownLatch latch = new CountDownLatch(1);
existingController.addListener(
new AbstractServiceListener<Object>() {
public void listenerAdded(ServiceController<?> serviceController) {
serviceController.setMode(ServiceController.Mode.REMOVE);
}
public void transition(
ServiceController<?> serviceController, ServiceController.Transition transition) {
if (transition.equals(ServiceController.Transition.REMOVING_to_REMOVED)) {
latch.countDown();
}
}
});
latch.await();
}
ServiceTarget target = serviceContainer.subTarget();
ControlledProcessState processState = new ControlledProcessState(true);
ModelControllerService svc = new ModelControllerService(processState, registration, model);
ServiceBuilder<ModelController> builder =
target.addService(ServiceName.of("ModelController"), svc);
builder.install();
svc.latch.await();
ModelController controller = svc.getValue();
ModelNode setup = Util.getEmptyOperation("setup", new ModelNode());
controller.execute(setup, null, null, null);
processState.setRunning();
return controller;
}
@Override
public void unregisterService(ServiceState serviceState) {
List<ServiceName> serviceNames = serviceState.getServiceNames();
log.debug("Unregister service: " + serviceNames);
AbstractBundle serviceOwner = serviceState.getServiceOwner();
// This event is synchronously delivered before the service has completed unregistering.
eventsPlugin.fireServiceEvent(serviceOwner, ServiceEvent.UNREGISTERING, serviceState);
// Remove from using bundles
for (AbstractBundle bundleState : serviceState.getUsingBundlesInternal()) {
while (ungetService(bundleState, serviceState)) ;
}
// Remove from owner bundle
serviceOwner.removeRegisteredService(serviceState);
// Unregister name associations
for (ServiceName serviceName : serviceNames) {
String[] clazzes = (String[]) serviceState.getProperty(Constants.OBJECTCLASS);
for (String clazz : clazzes) unregisterNameAssociation(clazz, serviceName);
}
// Remove from controller
ServiceName rootServiceName = serviceNames.get(0);
try {
ServiceController<?> controller = serviceContainer.getService(rootServiceName);
controller.setMode(Mode.REMOVE);
} catch (RuntimeException ex) {
log.error("Cannot remove service: " + rootServiceName, ex);
}
}
public void undeploy(DeploymentUnit context) {
final ServiceName moduleContextServiceName = ContextServiceNameBuilder.module(context);
final ServiceController<?> serviceController =
context.getServiceRegistry().getService(moduleContextServiceName);
if (serviceController != null) {
serviceController.setMode(ServiceController.Mode.REMOVE);
}
}
@SuppressWarnings("unchecked")
@Override
public final Object getObjectInstance(
Object obj, Name name, Context nameCtx, Hashtable<?, ?> environment) throws Exception {
final Reference reference = asReference(obj);
final ServiceNameRefAdr nameAdr = (ServiceNameRefAdr) reference.get("srof");
if (nameAdr == null) {
throw new NamingException("Invalid context reference. Not a 'srof' reference.");
}
final ServiceName serviceName = (ServiceName) nameAdr.getContent();
final ServiceController<?> controller;
try {
controller = serviceRegistry.getRequiredService(serviceName);
} catch (ServiceNotFoundException e) {
throw new NamingException("Could not resolve service " + serviceName);
}
ServiceReferenceListener listener = new ServiceReferenceListener();
controller.addListener(listener);
synchronized (listener) {
// if we are interrupted just let the exception propagate for now
while (!listener.finished) {
try {
listener.wait();
} catch (InterruptedException e) {
throw new NamingException(
"Thread interrupted while retrieving service reference for service " + serviceName);
}
}
}
switch (listener.getState()) {
case UP:
return getObjectInstance(listener.getValue(), obj, name, nameCtx, environment);
case START_FAILED:
throw new NamingException(
"Could not resolve service reference to "
+ serviceName
+ " in factory "
+ getClass().getName()
+ ". Service was in state START_FAILED.");
case REMOVED:
throw new NamingException(
"Could not resolve service reference to "
+ serviceName
+ " in factory "
+ getClass().getName()
+ ". Service was in state START_FAILED.");
}
// we should never get here, as the listener should not notify unless the state was one of the
// above
throw new NamingException(
"Could not resolve service reference to "
+ serviceName
+ " in factory "
+ getClass().getName()
+ ". This is a bug in ServiceReferenceObjectFactory. State was"
+ listener.getState());
}
/**
* Rollback runtime changes made in {@link #performRuntime(OperationContext,
* org.jboss.dmr.ModelNode, org.jboss.dmr.ModelNode, ServiceVerificationHandler, java.util.List)}.
*
* <p>This default implementation removes all services in the given list of {@code controllers}.
* The contents of {@code controllers} is the same as what was in the {@code newControllers}
* parameter passed to {@code performRuntime()} when that method returned.
*
* @param context the operation context
* @param operation the operation being executed
* @param model persistent configuration model node that corresponds to the address of {@code
* operation}
* @param controllers holder for the {@link ServiceController} for any new services installed by
* {@link #performRuntime(OperationContext, org.jboss.dmr.ModelNode, org.jboss.dmr.ModelNode,
* ServiceVerificationHandler, java.util.List)}
*/
protected void rollbackRuntime(
OperationContext context,
final ModelNode operation,
final ModelNode model,
List<ServiceController<?>> controllers) {
for (ServiceController<?> controller : controllers) {
context.removeService(controller.getName());
}
}
/**
* @return
* @deprecated {@link EJBUtilities} is deprecated post 7.2.0.Final version.
*/
@Deprecated
protected EJBUtilities getEJBUtilities() {
// constructs
final DeploymentUnit deploymentUnit = getDeploymentUnitInjector().getValue();
final ServiceController<EJBUtilities> serviceController =
(ServiceController<EJBUtilities>)
deploymentUnit.getServiceRegistry().getRequiredService(EJBUtilities.SERVICE_NAME);
return serviceController.getValue();
}
@Override
public synchronized void start(StartContext context) throws StartException {
ServiceController<?> controller = context.getController();
LOGGER.tracef("Starting: %s in mode %s", controller.getName(), controller.getMode());
try {
ServiceContainer serviceContainer = context.getController().getServiceContainer();
// Setup the OSGi {@link Framework} properties
SubsystemState subsystemState = injectedSubsystemState.getValue();
Map<String, Object> props = new HashMap<String, Object>(subsystemState.getProperties());
setupIntegrationProperties(context, props);
// Register the URLStreamHandlerFactory
Module coreFrameworkModule =
((ModuleClassLoader) FrameworkBuilder.class.getClassLoader()).getModule();
Module.registerURLStreamHandlerFactoryModule(coreFrameworkModule);
Module.registerContentHandlerFactoryModule(coreFrameworkModule);
ServiceTarget serviceTarget = context.getChildTarget();
JAXPServiceProvider.addService(serviceTarget);
ResolverService.addService(serviceTarget);
RepositoryService.addService(serviceTarget);
Activation activation = subsystemState.getActivationPolicy();
Mode initialMode = (activation == Activation.EAGER ? Mode.ACTIVE : Mode.LAZY);
// Configure the {@link Framework} builder
FrameworkBuilder builder = FrameworkBuilderFactory.create(props, initialMode);
builder.setServiceContainer(serviceContainer);
builder.setServiceTarget(serviceTarget);
builder.createFrameworkServices(serviceContainer, true);
builder.registerIntegrationService(FrameworkPhase.CREATE, new BundleLifecycleIntegration());
builder.registerIntegrationService(
FrameworkPhase.CREATE, new FrameworkModuleIntegration(props));
builder.registerIntegrationService(FrameworkPhase.CREATE, new ModuleLoaderIntegration());
builder.registerIntegrationService(
FrameworkPhase.CREATE, new SystemServicesIntegration(resource, extensions));
builder.registerIntegrationService(FrameworkPhase.INIT, new BootstrapBundlesIntegration());
builder.registerIntegrationService(
FrameworkPhase.INIT, new PersistentBundlesIntegration(deploymentTracker));
// Install the services to create the framework
builder.installServices(FrameworkPhase.CREATE, serviceTarget, verificationHandler);
if (activation == Activation.EAGER) {
builder.installServices(FrameworkPhase.INIT, serviceTarget, verificationHandler);
builder.installServices(FrameworkPhase.ACTIVE, serviceTarget, verificationHandler);
}
// Create the framework activator
FrameworkActivator.create(builder);
} catch (Throwable th) {
throw MESSAGES.startFailedToCreateFrameworkServices(th);
}
}
void setServiceMode(ServiceController<?> controller, Mode mode) {
try {
LOGGER.tracef("Set mode %s on service: %s", mode, controller.getName());
controller.setMode(mode);
} catch (IllegalArgumentException rte) {
// [MSC-105] Cannot determine whether container is shutting down
if (rte.getMessage().equals("Container is shutting down") == false) throw rte;
}
}
public Class<?> getEjbLocalObjectType() {
if (ejbLocalObjectViewServiceName == null) {
return null;
}
final ServiceController<?> serviceController =
currentServiceContainer().getRequiredService(ejbLocalObjectViewServiceName);
final ComponentView view = (ComponentView) serviceController.getValue();
return view.getViewClass();
}
protected <T> T createViewInstanceProxy(
final Class<T> viewInterface,
final Map<Object, Object> contextData,
final ServiceName serviceName) {
final ServiceController<?> serviceController =
CurrentServiceContainer.getServiceContainer().getRequiredService(serviceName);
final ComponentView view = (ComponentView) serviceController.getValue();
final ManagedReference instance = view.createInstance(contextData);
return viewInterface.cast(instance.getInstance());
}
private void testCustomFilters(KernelServices mainServices) {
ServiceController<FilterService> customFilter =
(ServiceController<FilterService>)
mainServices.getContainer().getService(UndertowService.FILTER.append("custom-filter"));
customFilter.setMode(ServiceController.Mode.ACTIVE);
FilterService connectionLimiterService = customFilter.getService().getValue();
HttpHandler result =
connectionLimiterService.createHttpHandler(Predicates.truePredicate(), new PathHandler());
Assert.assertNotNull("handler should have been created", result);
}
public static TransactionManager getTransactionManager(StartContext context) {
@SuppressWarnings("unchecked")
ServiceController<TransactionManager> service =
(ServiceController<TransactionManager>)
context
.getController()
.getServiceContainer()
.getService(TxnServices.JBOSS_TXN_TRANSACTION_MANAGER);
return service == null ? null : service.getValue();
}
private synchronized ContainerStateChangeReport createContainerStateChangeReport() {
final Map<ServiceName, Set<ServiceName>> missingDeps =
new HashMap<ServiceName, Set<ServiceName>>();
for (ServiceController<?> controller : servicesWithMissingDeps) {
for (ServiceName missing : controller.getImmediateUnavailableDependencies()) {
Set<ServiceName> dependents = missingDeps.get(missing);
if (dependents == null) {
dependents = new HashSet<ServiceName>();
missingDeps.put(missing, dependents);
}
dependents.add(controller.getName());
}
}
final Set<ServiceName> previousMissing = previousMissingDepSet;
// no longer missing deps...
final Map<ServiceName, Boolean> noLongerMissingServices = new TreeMap<ServiceName, Boolean>();
for (ServiceName name : previousMissing) {
if (!missingDeps.containsKey(name)) {
ServiceController<?> controller = serviceRegistry.getService(name);
noLongerMissingServices.put(name, controller == null);
}
}
// newly missing deps
final Map<ServiceName, MissingDependencyInfo> missingServices =
new TreeMap<ServiceName, MissingDependencyInfo>();
for (Map.Entry<ServiceName, Set<ServiceName>> entry : missingDeps.entrySet()) {
final ServiceName name = entry.getKey();
if (!previousMissing.contains(name)) {
ServiceController<?> controller = serviceRegistry.getService(name);
boolean unavailable = controller != null;
missingServices.put(name, new MissingDependencyInfo(name, unavailable, entry.getValue()));
}
}
final Map<ServiceController<?>, String> currentFailedControllers =
new HashMap<ServiceController<?>, String>(failedControllers);
previousMissingDepSet = new HashSet<ServiceName>(missingDeps.keySet());
failedControllers.clear();
boolean needReport =
!missingServices.isEmpty()
|| !currentFailedControllers.isEmpty()
|| !noLongerMissingServices.isEmpty();
return needReport
? new ContainerStateChangeReport(
missingServices, currentFailedControllers, noLongerMissingServices)
: null;
}
private void handleStateChange(ServiceController controller) {
state = controller.getState();
if (state == State.UP) {
value = controller.getValue();
}
if (state == State.UP || state == State.START_FAILED || state == State.REMOVED) {
controller.removeListener(this);
finished = true;
notifyAll();
}
}
/**
* Returns the name of the resource adapter which will be used as the default RA for MDBs (unless
* overridden by the MDBs).
*
* @param serviceRegistry
* @return
*/
private String getDefaultResourceAdapterName(final ServiceRegistry serviceRegistry) {
if (appclient) {
// we must report the MDB, but we can't use any MDB/JCA facilities
return "n/a";
}
final ServiceController<DefaultResourceAdapterService> serviceController =
(ServiceController<DefaultResourceAdapterService>)
serviceRegistry.getRequiredService(
DefaultResourceAdapterService.DEFAULT_RA_NAME_SERVICE_NAME);
return serviceController.getValue().getDefaultResourceAdapterName();
}
/** {@inheritDoc} */
public void serviceFailed(
ServiceController<? extends Object> serviceController, StartException reason) {
final ServiceName serviceName = serviceController.getName();
log.errorf(reason, "Service [%s] start failed", serviceName);
serviceFailures.put(serviceName, reason);
if (!expectedOnDemandServices.contains(serviceController.getName())
&& countUpdater.decrementAndGet(this) == 0) {
batchComplete();
}
serviceController.removeListener(this);
}
/** {@inheritDoc} */
public void serviceStarted(final ServiceController<? extends Object> serviceController) {
startedServicesUpdater.incrementAndGet(this);
if (expectedOnDemandServices.contains(serviceController.getName())) {
startedOnDemandServicesUpdater.incrementAndGet(this);
}
if (!expectedOnDemandServices.contains(serviceController.getName())
&& countUpdater.decrementAndGet(this) == 0) {
batchComplete();
}
serviceController.removeListener(this);
}
private AddressControl getAddressControl(
final OperationContext context, final ModelNode operation) {
final String addressName =
PathAddress.pathAddress(operation.require(OP_ADDR)).getLastElement().getValue();
final ServiceName hqServiceName =
MessagingServices.getHornetQServiceName(
PathAddress.pathAddress(operation.get(ModelDescriptionConstants.OP_ADDR)));
ServiceController<?> hqService = context.getServiceRegistry(false).getService(hqServiceName);
HornetQServer hqServer = HornetQServer.class.cast(hqService.getValue());
return AddressControl.class.cast(
hqServer.getManagementService().getResource(ResourceNames.CORE_ADDRESS + addressName));
}
private void initializeModeShapeEngine(
final OperationContext context,
final ModelNode operation,
ModelNode model,
final List<ServiceController<?>> newControllers) {
ServiceTarget target = context.getServiceTarget();
final JBossLifeCycleListener shutdownListener = new JBossLifeCycleListener();
engine = buildModeShapeEngine(model);
// Engine service
ServiceBuilder<JcrEngine> engineBuilder =
target.addService(ModeShapeServiceNames.ENGINE, engine);
engineBuilder.setInitialMode(ServiceController.Mode.ACTIVE);
ServiceController<JcrEngine> controller = engineBuilder.install();
controller.getServiceContainer().addTerminateListener(shutdownListener);
newControllers.add(controller);
// JNDI Binding
final ReferenceFactoryService<JcrEngine> referenceFactoryService =
new ReferenceFactoryService<JcrEngine>();
final ServiceName referenceFactoryServiceName =
ModeShapeServiceNames.ENGINE.append("reference-factory"); // $NON-NLS-1$
final ServiceBuilder<?> referenceBuilder =
target.addService(referenceFactoryServiceName, referenceFactoryService);
referenceBuilder.addDependency(
ModeShapeServiceNames.ENGINE, JcrEngine.class, referenceFactoryService.getInjector());
referenceBuilder.setInitialMode(ServiceController.Mode.ACTIVE);
final ContextNames.BindInfo bindInfo =
ContextNames.bindInfoFor(ModeShapeJndiNames.JNDI_BASE_NAME);
final BinderService binderService = new BinderService(bindInfo.getBindName());
final ServiceBuilder<?> binderBuilder =
target.addService(bindInfo.getBinderServiceName(), binderService);
binderBuilder.addDependency(
ModeShapeServiceNames.ENGINE,
JcrEngine.class,
new ManagedReferenceInjector<JcrEngine>(binderService.getManagedObjectInjector()));
binderBuilder.addDependency(
bindInfo.getParentContextServiceName(),
ServiceBasedNamingStore.class,
binderService.getNamingStoreInjector());
binderBuilder.setInitialMode(ServiceController.Mode.ACTIVE);
Logger.getLogger(getClass())
.debug("Binding ModeShape to JNDI name '{0}'", bindInfo.getAbsoluteJndiName());
newControllers.add(referenceBuilder.install());
newControllers.add(binderBuilder.install());
}
private AuthorizingCallbackHandler getAuthorizingCallbackHandler(final String realmName) {
SecurityRealm realm;
if (TEST_REALM.equals(realmName)) {
realm = securityRealm;
} else {
ServiceContainer container = getContainer();
ServiceController<?> service =
container.getRequiredService(SecurityRealm.ServiceUtil.createServiceName(realmName));
realm = (SecurityRealm) service.getValue();
}
return realm.getAuthorizingCallbackHandler(AuthMechanism.PLAIN);
}
@Test
public void testMetadataConfiguration() throws Throwable {
ServiceController<?> controller =
serviceContainer.getService(ConnectorServices.IRONJACAMAR_MDR);
assertNotNull(controller);
MetadataRepository repository = (MetadataRepository) controller.getValue();
assertNotNull(repository);
Set<String> ids = repository.getResourceAdapters();
assertNotNull(ids);
String piId = ids.iterator().next();
assertNotNull(piId);
assertNotNull(repository.getResourceAdapter(piId));
}
protected <T> T createViewInstanceProxy(
final Class<T> viewInterface,
final Map<Object, Object> contextData,
final ServiceName serviceName) {
final ServiceController<?> serviceController =
currentServiceContainer().getRequiredService(serviceName);
final ComponentView view = (ComponentView) serviceController.getValue();
final ManagedReference instance;
try {
instance = view.createInstance(contextData);
} catch (Exception e) {
// TODO: do we need to let the exception propagate here?
throw new RuntimeException(e);
}
return viewInterface.cast(instance.getInstance());
}
public EJBHome getEJBHome() throws IllegalStateException {
if (ejbHomeViewServiceName == null) {
throw MESSAGES.beanHomeInterfaceIsNull(getComponentName());
}
final ServiceController<?> serviceController =
currentServiceContainer().getRequiredService(ejbHomeViewServiceName);
final ComponentView view = (ComponentView) serviceController.getValue();
final String locatorAppName = earApplicationName == null ? "" : earApplicationName;
return EJBClient.createProxy(
new EJBHomeLocator<EJBHome>(
(Class<EJBHome>) view.getViewClass(),
locatorAppName,
moduleName,
getComponentName(),
distinctName));
}