Esempio n. 1
0
/** @author <a href="mailto:[email protected]">David M. Lloyd</a> */
public final class LogServices {

  public static final ServiceName JBOSS_LOGGING = ServiceName.JBOSS.append("logging");

  public static final ServiceName LOGGER = JBOSS_LOGGING.append("logger");

  public static final ServiceName ROOT_LOGGER = JBOSS_LOGGING.append("root-logger");

  public static final ServiceName LOGGER_HANDLER = JBOSS_LOGGING.append("logger-handler");

  public static final ServiceName ROOT_LOGGER_HANDLER = JBOSS_LOGGING.append("root-logger-handler");

  public static final ServiceName HANDLER = JBOSS_LOGGING.append("handler");

  private LogServices() {}

  public static ServiceName loggerName(final String name) {
    return "".equals(name) ? ROOT_LOGGER : LOGGER.append(name);
  }

  public static ServiceName loggerHandlerName(final String loggerName, final String handlerName) {
    return loggerName.length() == 0
        ? ROOT_LOGGER_HANDLER.append(handlerName)
        : LOGGER_HANDLER.append(loggerName, handlerName);
  }

  public static ServiceName handlerName(final String name) {
    return HANDLER.append(name);
  }
}
Esempio n. 2
0
 /**
  * Get the service name of a context, or {@code null} if there is no service mapping for the
  * context name.
  *
  * @param app the application name
  * @param module the module name
  * @param comp the component name
  * @param context the context to check
  * @return the service name or {@code null} if there is no service
  */
 public static ServiceName serviceNameOfContext(
     String app, String module, String comp, String context) {
   if (context.startsWith("java:")) {
     final String namespace;
     final int i = context.indexOf('/');
     if (i == -1) {
       namespace = context.substring(5);
     } else {
       namespace = context.substring(5, i);
     }
     if (namespace.equals("global")) {
       return GLOBAL_CONTEXT_SERVICE_NAME.append(context.substring(12));
     } else if (namespace.equals("jboss")) {
       return JBOSS_CONTEXT_SERVICE_NAME.append(context.substring(11));
     } else if (namespace.equals("app")) {
       return contextServiceNameOfApplication(app).append(context.substring(9));
     } else if (namespace.equals("module")) {
       return contextServiceNameOfModule(app, module).append(context.substring(12));
     } else if (namespace.equals("comp")) {
       return contextServiceNameOfComponent(app, module, comp).append(context.substring(10));
     } else {
       return JAVA_CONTEXT_SERVICE_NAME.append(context);
     }
   } else {
     return null;
   }
 }
  /**
   * Add a ContextService for this module.
   *
   * @param phaseContext the deployment unit context
   * @throws org.jboss.as.server.deployment.DeploymentUnitProcessingException
   */
  public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException {
    final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
    if (isEarDeployment(deploymentUnit)) {
      return;
    }
    final ServiceTarget serviceTarget = phaseContext.getServiceTarget();

    final ServiceName moduleContextServiceName = ContextServiceNameBuilder.module(deploymentUnit);
    final RootContextService contextService = new RootContextService();
    serviceTarget.addService(moduleContextServiceName, contextService).install();

    final BinderService<String> moduleNameBinder =
        new BinderService<String>(
            "ModuleName", Values.immediateValue(getModuleName(deploymentUnit)));
    serviceTarget
        .addService(moduleContextServiceName.append("ModuleName"), moduleNameBinder)
        .addDependency(
            moduleContextServiceName, Context.class, moduleNameBinder.getContextInjector())
        .install();

    final ContextService envContextService = new ContextService("env");
    serviceTarget
        .addService(moduleContextServiceName.append("env"), envContextService)
        .addDependency(
            moduleContextServiceName, Context.class, envContextService.getParentContextInjector())
        .install();

    phaseContext
        .getDeploymentUnit()
        .putAttachment(
            Attachments.MODULE_CONTEXT_CONFIG, new NamingContextConfig(moduleContextServiceName));
  }
  /**
   * Check the deployment annotation index for all classes with the @ManagedBean annotation. For
   * each class with the annotation, collect all the required information to create a managed bean
   * instance, and attach it to the context.
   *
   * @param phaseContext the deployment unit context
   * @throws DeploymentUnitProcessingException
   */
  public void deploy(DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException {
    final DeploymentUnit deploymentUnit = phaseContext.getDeploymentUnit();
    final EEModuleDescription moduleDescription =
        deploymentUnit.getAttachment(org.jboss.as.ee.component.Attachments.EE_MODULE_DESCRIPTION);
    final String applicationName = moduleDescription.getAppName();
    final CompositeIndex compositeIndex =
        deploymentUnit.getAttachment(Attachments.COMPOSITE_ANNOTATION_INDEX);
    if (compositeIndex == null) {
      return;
    }
    final List<AnnotationInstance> instances =
        compositeIndex.getAnnotations(MANAGED_BEAN_ANNOTATION_NAME);
    if (instances == null || instances.isEmpty()) {
      return;
    }

    for (AnnotationInstance instance : instances) {
      AnnotationTarget target = instance.target();
      if (!(target instanceof ClassInfo)) {
        throw new DeploymentUnitProcessingException(
            "The ManagedBean annotation is only allowed at the class level: " + target);
      }
      final ClassInfo classInfo = (ClassInfo) target;
      final String beanClassName = classInfo.name().toString();

      // Get the managed bean name from the annotation
      final AnnotationValue nameValue = instance.value();
      final String beanName =
          nameValue == null || nameValue.asString().isEmpty()
              ? beanClassName
              : nameValue.asString();
      final ManagedBeanComponentDescription componentDescription =
          new ManagedBeanComponentDescription(
              beanName, beanClassName, moduleDescription.getModuleName(), applicationName);
      final ServiceName baseName =
          deploymentUnit.getServiceName().append("component").append(beanName);

      // Add the view
      componentDescription.getViewClassNames().add(beanClassName);

      // Bind the view to its two JNDI locations
      // TODO - this should be a bit more elegant
      final BindingDescription moduleBinding = new BindingDescription();
      moduleBinding.setAbsoluteBinding(true);
      moduleBinding.setBindingName("java:module/" + beanName);
      moduleBinding.setBindingType(beanClassName);
      moduleBinding.setReferenceSourceDescription(
          new ServiceBindingSourceDescription(baseName.append("VIEW").append(beanClassName)));
      componentDescription.getBindings().add(moduleBinding);
      final BindingDescription appBinding = new BindingDescription();
      appBinding.setAbsoluteBinding(true);
      appBinding.setBindingName("java:app/" + moduleDescription.getModuleName() + "/" + beanName);
      appBinding.setBindingType(beanClassName);
      appBinding.setReferenceSourceDescription(
          new ServiceBindingSourceDescription(baseName.append("VIEW").append(beanClassName)));
      componentDescription.getBindings().add(appBinding);
      moduleDescription.addComponent(componentDescription);
    }
  }
/** @author Emanuel Muckenhuber */
public final class PlayServices {

  /** The service name of the play framework configuration. */
  public static final ServiceName PLAY = ServiceName.JBOSS.append("play");

  public static final ServiceName PLAY_DEPLOYMENT = PLAY.append("deployment");

  /** internal name for the framework path service name. */
  static final ServiceName PLAY_PATH = PLAY.append("path");
}
 private static ServiceName getCacheServiceName(String cacheName) {
   ServiceName baseServiceName =
       CacheContainerServiceName.CACHE_CONTAINER
           .getServiceName(DEFAULT_CACHE_CONTAINER)
           .getParent();
   ServiceName serviceName =
       ServiceName.parse((cacheName != null) ? cacheName : DEFAULT_CACHE_CONTAINER);
   if (!baseServiceName.isParentOf(serviceName)) {
     serviceName = baseServiceName.append(serviceName);
   }
   return (serviceName.length() < 4)
       ? serviceName.append(SubGroupServiceNameFactory.DEFAULT_SUB_GROUP)
       : serviceName;
 }
 private static ServiceName installSessionManagerFactory(
     ServiceTarget target,
     ServiceName deploymentServiceName,
     String deploymentName,
     Module module,
     JBossWebMetaData metaData) {
   ServiceName name = deploymentServiceName.append("session");
   if (metaData.getDistributable() != null) {
     DistributableSessionManagerFactoryBuilder sessionManagerFactoryBuilder =
         new DistributableSessionManagerFactoryBuilderValue().getValue();
     if (sessionManagerFactoryBuilder != null) {
       sessionManagerFactoryBuilder
           .build(
               target,
               name,
               new SimpleDistributableSessionManagerConfiguration(
                   metaData, deploymentName, module))
           .setInitialMode(Mode.ON_DEMAND)
           .install();
       return name;
     }
     // Fallback to local session manager if server does not support clustering
     UndertowLogger.ROOT_LOGGER.clusteringNotSupported();
   }
   Integer maxActiveSessions = metaData.getMaxActiveSessions();
   InMemorySessionManagerFactory factory =
       (maxActiveSessions != null)
           ? new InMemorySessionManagerFactory(maxActiveSessions.intValue())
           : new InMemorySessionManagerFactory();
   target
       .addService(name, new ValueService<>(new ImmediateValue<>(factory)))
       .setInitialMode(Mode.ON_DEMAND)
       .install();
   return name;
 }
  @Override
  public void deploy(DeploymentPhaseContext context) {

    DeploymentUnit unit = context.getDeploymentUnit();
    final ServiceName name = unit.getServiceName();
    EEModuleDescription moduleDescription = unit.getAttachment(Attachments.EE_MODULE_DESCRIPTION);
    if (moduleDescription == null) {
      return;
    }

    final ServiceTarget target = context.getServiceTarget();
    @SuppressWarnings("rawtypes")
    final InjectedValue<CacheFactoryBuilderRegistry> registry = new InjectedValue<>();
    Service<Void> service =
        new AbstractService<Void>() {
          @Override
          public void start(StartContext context) {
            // Install dependencies for each registered cache factory builder
            Collection<CacheFactoryBuilder<?, ?>> builders = registry.getValue().getBuilders();
            for (CacheFactoryBuilder<?, ?> builder : builders) {
              builder.installDeploymentUnitDependencies(target, name);
            }
          }
        };
    target
        .addService(name.append("cache-dependencies-installer"), service)
        .addDependency(
            CacheFactoryBuilderRegistryService.SERVICE_NAME,
            CacheFactoryBuilderRegistry.class,
            registry)
        .install();

    // Install versioned marshalling configuration
    InjectedValue<ModuleDeployment> deployment = new InjectedValue<>();
    Module module = unit.getAttachment(org.jboss.as.server.deployment.Attachments.MODULE);
    Value<ModuleLoader> moduleLoader = new ImmediateValue<>(module.getModuleLoader());
    target
        .addService(
            VersionedMarshallingConfigurationService.getServiceName(name),
            new VersionedMarshallingConfigurationService(deployment, moduleLoader))
        .addDependency(
            name.append(ModuleDeployment.SERVICE_NAME), ModuleDeployment.class, deployment)
        .setInitialMode(ServiceController.Mode.ON_DEMAND)
        .install();
  }
 private ServiceName buildServiceName(final Name name) {
   final Enumeration<String> parts = name.getAll();
   ServiceName current = serviceNameBase;
   while (parts.hasMoreElements()) {
     final String currentPart = parts.nextElement();
     if (!currentPart.isEmpty()) {
       current = current.append(currentPart);
     }
   }
   return current;
 }
 @Override
 public ServiceName getServiceName(Deployment dep, int state) {
   // Currently the bundleId is needed for uniqueness because of
   // [MSC-97] Cannot re-install service with same name
   Long bundleId = dep.getAttachment(Long.class);
   ServiceName serviceName =
       ServiceName.of(
           BUNDLE_BASE_NAME, "" + bundleId, "" + dep.getSymbolicName(), "" + dep.getVersion());
   if (state == Bundle.INSTALLED || state == Bundle.RESOLVED || state == Bundle.ACTIVE) {
     serviceName = serviceName.append(ConstantsHelper.bundleState(state));
   }
   return serviceName;
 }
  private void bindServices(
      DeploymentUnit deploymentUnit, ServiceTarget serviceTarget, ServiceName contextServiceName) {

    final ServiceName instanceNameServiceName = contextServiceName.append("InstanceName");
    final BinderService instanceNameService = new BinderService("InstanceName");
    serviceTarget
        .addService(instanceNameServiceName, instanceNameService)
        .addDependency(
            contextServiceName,
            ServiceBasedNamingStore.class,
            instanceNameService.getNamingStoreInjector())
        .addDependency(
            ServerEnvironmentService.SERVICE_NAME,
            ServerEnvironment.class,
            new Injector<ServerEnvironment>() {
              @Override
              public void inject(final ServerEnvironment serverEnvironment)
                  throws InjectionException {
                instanceNameService
                    .getManagedObjectInjector()
                    .inject(
                        new ManagedReferenceFactory() {
                          @Override
                          public ManagedReference getReference() {
                            return new ManagedReference() {
                              @Override
                              public void release() {}

                              @Override
                              public Object getInstance() {
                                final String nodeName = serverEnvironment.getNodeName();
                                return nodeName == null ? "" : nodeName;
                              }
                            };
                          }
                        });
              }

              @Override
              public void uninject() {
                instanceNameService.getManagedObjectInjector().uninject();
              }
            })
        .install();
    deploymentUnit.addToAttachmentList(
        org.jboss.as.server.deployment.Attachments.JNDI_DEPENDENCIES, instanceNameServiceName);
  }
 private void bindBeanManager(
     ServiceTarget serviceTarget,
     ServiceName beanManagerServiceName,
     ServiceName contextServiceName,
     final Collection<ServiceName> dependencies,
     final ServiceRegistry serviceRegistry) {
   final ServiceName beanManagerBindingServiceName = contextServiceName.append("BeanManager");
   dependencies.add(beanManagerBindingServiceName);
   BinderService beanManagerBindingService = new BinderService("BeanManager");
   final BeanManagerManagedReferenceFactory referenceFactory =
       new BeanManagerManagedReferenceFactory();
   serviceTarget
       .addService(beanManagerBindingServiceName, beanManagerBindingService)
       .addInjection(beanManagerBindingService.getManagedObjectInjector(), referenceFactory)
       .addDependency(
           contextServiceName,
           ServiceBasedNamingStore.class,
           beanManagerBindingService.getNamingStoreInjector())
       .addDependency(beanManagerServiceName, BeanManager.class, referenceFactory.beanManager)
       .install();
 }
Esempio n. 13
0
public class ServicesServices {

  private ServicesServices() {}

  public static final ServiceName TORQUEBOX = ServiceName.of("torquebox");
  public static final ServiceName SERVICES = TORQUEBOX.append("services");

  public static ServiceName serviceComponentResolver(DeploymentUnit unit, String serviceName) {
    return unit.getServiceName().append("component_resolver").append(serviceName);
  }

  public static ServiceName serviceCreateRubyService(DeploymentUnit unit, String serviceName) {
    return unit.getServiceName().append("service").append(serviceName).append("create");
  }

  public static ServiceName serviceStartRubyService(DeploymentUnit unit, String serviceName) {
    return unit.getServiceName().append("service").append(serviceName);
  }

  public static ServiceName serviceInjectableService(DeploymentUnit unit, String serviceName) {
    return serviceStartRubyService(unit, serviceName).append("injectable");
  }
}
 private static ServiceName installSessionIdentifierCodec(
     ServiceTarget target,
     ServiceName deploymentServiceName,
     String deploymentName,
     JBossWebMetaData metaData) {
   ServiceName name = deploymentServiceName.append("codec");
   if (metaData.getDistributable() != null) {
     DistributableSessionIdentifierCodecBuilder sessionIdentifierCodecBuilder =
         new DistributableSessionIdentifierCodecBuilderValue().getValue();
     if (sessionIdentifierCodecBuilder != null) {
       sessionIdentifierCodecBuilder
           .build(target, name, deploymentName)
           .setInitialMode(Mode.ON_DEMAND)
           .install();
       return name;
     }
     // Fallback to simple codec if server does not support clustering
   }
   SimpleSessionIdentifierCodecService.build(target, name)
       .setInitialMode(Mode.ON_DEMAND)
       .install();
   return name;
 }
Esempio n. 15
0
/** @author <a href="mailto:[email protected]">David M. Lloyd</a> */
public final class LogServices {

  public static final ServiceName JBOSS_LOGGING = ServiceName.JBOSS.append("logging");

  public static final ServiceName LOGGER = JBOSS_LOGGING.append("logger");

  public static final ServiceName ROOT_LOGGER =
      JBOSS_LOGGING.append("root-logger", CommonAttributes.ROOT_LOGGER_NAME);

  public static final ServiceName LOGGER_HANDLER = JBOSS_LOGGING.append("logger-handler");

  public static final ServiceName ROOT_LOGGER_HANDLER = JBOSS_LOGGING.append("root-logger-handler");

  public static final ServiceName HANDLER = JBOSS_LOGGING.append("handler");

  public static final ServiceName HANDLER_FILE = JBOSS_LOGGING.append("handler-file");

  private LogServices() {}

  public static ServiceName loggerName(final String name) {
    return CommonAttributes.ROOT_LOGGER_NAME.equals(name) ? ROOT_LOGGER : LOGGER.append(name);
  }

  public static ServiceName loggerHandlerName(final String loggerName, final String handlerName) {
    return CommonAttributes.ROOT_LOGGER_NAME.equals(loggerName)
        ? ROOT_LOGGER_HANDLER.append(CommonAttributes.ROOT_LOGGER_NAME, handlerName)
        : LOGGER_HANDLER.append(loggerName, handlerName);
  }

  public static ServiceName handlerName(final String name) {
    return HANDLER.append(name);
  }

  public static ServiceName handlerFileName(final String handlerName) {
    return HANDLER_FILE.append(handlerName);
  }
}
  private void processDeployment(
      final WarMetaData warMetaData,
      final DeploymentUnit deploymentUnit,
      final ServiceTarget serviceTarget,
      String hostName)
      throws DeploymentUnitProcessingException {
    ResourceRoot deploymentResourceRoot = deploymentUnit.getAttachment(Attachments.DEPLOYMENT_ROOT);
    final VirtualFile deploymentRoot = deploymentResourceRoot.getRoot();
    final Module module = deploymentUnit.getAttachment(Attachments.MODULE);
    if (module == null) {
      throw new DeploymentUnitProcessingException(
          UndertowLogger.ROOT_LOGGER.failedToResolveModule(deploymentUnit));
    }
    final JBossWebMetaData metaData = warMetaData.getMergedJBossWebMetaData();
    final List<SetupAction> setupActions =
        deploymentUnit.getAttachmentList(org.jboss.as.ee.component.Attachments.WEB_SETUP_ACTIONS);
    metaData.resolveRunAs();

    ScisMetaData scisMetaData = deploymentUnit.getAttachment(ScisMetaData.ATTACHMENT_KEY);

    final Set<ServiceName> dependentComponents = new HashSet<>();
    // see AS7-2077
    // basically we want to ignore components that have failed for whatever reason
    // if they are important they will be picked up when the web deployment actually starts
    final List<ServiceName> components =
        deploymentUnit.getAttachmentList(WebComponentDescription.WEB_COMPONENTS);
    final Set<ServiceName> failed =
        deploymentUnit.getAttachment(org.jboss.as.ee.component.Attachments.FAILED_COMPONENTS);
    for (final ServiceName component : components) {
      if (!failed.contains(component)) {
        dependentComponents.add(component);
      }
    }

    boolean componentRegistryExists = true;
    ComponentRegistry componentRegistry =
        deploymentUnit.getAttachment(org.jboss.as.ee.component.Attachments.COMPONENT_REGISTRY);
    if (componentRegistry == null) {
      componentRegistryExists = false;
      // we do this to avoid lots of other null checks
      // this will only happen if the EE subsystem is not installed
      componentRegistry = new ComponentRegistry(null);
    }

    final WebInjectionContainer injectionContainer =
        new WebInjectionContainer(module.getClassLoader(), componentRegistry);

    String jaccContextId = metaData.getJaccContextID();

    if (jaccContextId == null) {
      jaccContextId = deploymentUnit.getName();
    }
    if (deploymentUnit.getParent() != null) {
      jaccContextId = deploymentUnit.getParent().getName() + "!" + jaccContextId;
    }

    String deploymentName;
    if (deploymentUnit.getParent() == null) {
      deploymentName = deploymentUnit.getName();
    } else {
      deploymentName = deploymentUnit.getParent().getName() + "." + deploymentUnit.getName();
    }

    final String pathName = pathNameOfDeployment(deploymentUnit, metaData);

    boolean securityEnabled = deploymentUnit.hasAttachment(SecurityAttachments.SECURITY_ENABLED);

    String metaDataSecurityDomain = metaData.getSecurityDomain();
    if (metaDataSecurityDomain == null) {
      metaDataSecurityDomain = getJBossAppSecurityDomain(deploymentUnit);
    }
    if (metaDataSecurityDomain != null) {
      metaDataSecurityDomain = metaDataSecurityDomain.trim();
    }

    final String securityDomain;
    if (securityEnabled) {
      securityDomain =
          metaDataSecurityDomain == null
              ? SecurityConstants.DEFAULT_APPLICATION_POLICY
              : SecurityUtil.unprefixSecurityDomain(metaDataSecurityDomain);
    } else {
      securityDomain = null;
    }

    String serverInstanceName =
        metaData.getServerInstanceName() == null ? defaultServer : metaData.getServerInstanceName();
    final ServiceName deploymentServiceName =
        UndertowService.deploymentServiceName(serverInstanceName, hostName, pathName);

    final Set<ServiceName> additionalDependencies = new HashSet<>();
    for (final SetupAction setupAction : setupActions) {
      Set<ServiceName> dependencies = setupAction.dependencies();
      if (dependencies != null) {
        additionalDependencies.addAll(dependencies);
      }
    }
    SharedSessionManagerConfig sharedSessionManagerConfig =
        deploymentUnit.getParent() != null
            ? deploymentUnit
                .getParent()
                .getAttachment(UndertowAttachments.SHARED_SESSION_MANAGER_CONFIG)
            : null;

    if (!deploymentResourceRoot.isUsePhysicalCodeSource()) {
      try {
        deploymentUnit.addToAttachmentList(
            ServletContextAttribute.ATTACHMENT_KEY,
            new ServletContextAttribute(
                Constants.CODE_SOURCE_ATTRIBUTE_NAME, deploymentRoot.toURL()));
      } catch (MalformedURLException e) {
        throw new DeploymentUnitProcessingException(e);
      }
    }

    deploymentUnit.addToAttachmentList(
        ServletContextAttribute.ATTACHMENT_KEY,
        new ServletContextAttribute(
            Constants.PERMISSION_COLLECTION_ATTRIBUTE_NAME,
            deploymentUnit.getAttachment(Attachments.MODULE_PERMISSIONS)));

    additionalDependencies.addAll(warMetaData.getAdditionalDependencies());

    final ServiceName hostServiceName =
        UndertowService.virtualHostName(serverInstanceName, hostName);
    TldsMetaData tldsMetaData = deploymentUnit.getAttachment(TldsMetaData.ATTACHMENT_KEY);
    UndertowDeploymentInfoService undertowDeploymentInfoService =
        UndertowDeploymentInfoService.builder()
            .setAttributes(deploymentUnit.getAttachmentList(ServletContextAttribute.ATTACHMENT_KEY))
            .setTopLevelDeploymentName(
                deploymentUnit.getParent() == null
                    ? deploymentUnit.getName()
                    : deploymentUnit.getParent().getName())
            .setContextPath(pathName)
            .setDeploymentName(
                deploymentName) // todo: is this deployment name concept really applicable?
            .setDeploymentRoot(deploymentRoot)
            .setMergedMetaData(warMetaData.getMergedJBossWebMetaData())
            .setModule(module)
            .setScisMetaData(scisMetaData)
            .setJaccContextId(jaccContextId)
            .setSecurityDomain(securityDomain)
            .setSharedTlds(
                tldsMetaData == null
                    ? Collections.<TldMetaData>emptyList()
                    : tldsMetaData.getSharedTlds(deploymentUnit))
            .setTldsMetaData(tldsMetaData)
            .setSetupActions(setupActions)
            .setSharedSessionManagerConfig(sharedSessionManagerConfig)
            .setOverlays(warMetaData.getOverlays())
            .setExpressionFactoryWrappers(
                deploymentUnit.getAttachmentList(ExpressionFactoryWrapper.ATTACHMENT_KEY))
            .setPredicatedHandlers(
                deploymentUnit.getAttachment(
                    UndertowHandlersDeploymentProcessor.PREDICATED_HANDLERS))
            .setInitialHandlerChainWrappers(
                deploymentUnit.getAttachmentList(
                    UndertowAttachments.UNDERTOW_INITIAL_HANDLER_CHAIN_WRAPPERS))
            .setInnerHandlerChainWrappers(
                deploymentUnit.getAttachmentList(
                    UndertowAttachments.UNDERTOW_INNER_HANDLER_CHAIN_WRAPPERS))
            .setOuterHandlerChainWrappers(
                deploymentUnit.getAttachmentList(
                    UndertowAttachments.UNDERTOW_OUTER_HANDLER_CHAIN_WRAPPERS))
            .setThreadSetupActions(
                deploymentUnit.getAttachmentList(UndertowAttachments.UNDERTOW_THREAD_SETUP_ACTIONS))
            .setServletExtensions(
                deploymentUnit.getAttachmentList(UndertowAttachments.UNDERTOW_SERVLET_EXTENSIONS))
            .setExplodedDeployment(ExplodedDeploymentMarker.isExplodedDeployment(deploymentUnit))
            .setWebSocketDeploymentInfo(
                deploymentUnit.getAttachment(UndertowAttachments.WEB_SOCKET_DEPLOYMENT_INFO))
            .setTempDir(warMetaData.getTempDir())
            .setExternalResources(
                deploymentUnit.getAttachmentList(UndertowAttachments.EXTERNAL_RESOURCES))
            .createUndertowDeploymentInfoService();

    final ServiceName deploymentInfoServiceName =
        deploymentServiceName.append(UndertowDeploymentInfoService.SERVICE_NAME);
    ServiceBuilder<DeploymentInfo> infoBuilder =
        serviceTarget
            .addService(deploymentInfoServiceName, undertowDeploymentInfoService)
            .addDependency(
                UndertowService.SERVLET_CONTAINER.append(defaultContainer),
                ServletContainerService.class,
                undertowDeploymentInfoService.getContainer())
            .addDependency(
                UndertowService.UNDERTOW,
                UndertowService.class,
                undertowDeploymentInfoService.getUndertowService())
            .addDependencies(deploymentUnit.getAttachmentList(Attachments.WEB_DEPENDENCIES))
            .addDependency(hostServiceName, Host.class, undertowDeploymentInfoService.getHost())
            .addDependency(
                SuspendController.SERVICE_NAME,
                SuspendController.class,
                undertowDeploymentInfoService.getSuspendControllerInjectedValue())
            .addDependencies(additionalDependencies);
    if (securityDomain != null) {
      infoBuilder.addDependency(
          SecurityDomainService.SERVICE_NAME.append(securityDomain),
          SecurityDomainContext.class,
          undertowDeploymentInfoService.getSecurityDomainContextValue());
    }

    if (RequestControllerActivationMarker.isRequestControllerEnabled(deploymentUnit)) {
      String topLevelName;
      if (deploymentUnit.getParent() == null) {
        topLevelName = deploymentUnit.getName();
      } else {
        topLevelName = deploymentUnit.getParent().getName();
      }
      infoBuilder.addDependency(
          ControlPointService.serviceName(topLevelName, UndertowExtension.SUBSYSTEM_NAME),
          ControlPoint.class,
          undertowDeploymentInfoService.getControlPointInjectedValue());
    }
    final Set<String> seenExecutors = new HashSet<String>();
    if (metaData.getExecutorName() != null) {
      final InjectedValue<Executor> executor = new InjectedValue<Executor>();
      infoBuilder.addDependency(
          IOServices.WORKER.append(metaData.getExecutorName()), Executor.class, executor);
      undertowDeploymentInfoService.addInjectedExecutor(metaData.getExecutorName(), executor);
      seenExecutors.add(metaData.getExecutorName());
    }
    if (metaData.getServlets() != null) {
      for (JBossServletMetaData servlet : metaData.getServlets()) {
        if (servlet.getExecutorName() != null
            && !seenExecutors.contains(servlet.getExecutorName())) {
          final InjectedValue<Executor> executor = new InjectedValue<Executor>();
          infoBuilder.addDependency(
              IOServices.WORKER.append(servlet.getExecutorName()), Executor.class, executor);
          undertowDeploymentInfoService.addInjectedExecutor(servlet.getExecutorName(), executor);
          seenExecutors.add(servlet.getExecutorName());
        }
      }
    }

    if (componentRegistryExists) {
      infoBuilder.addDependency(
          ComponentRegistry.serviceName(deploymentUnit),
          ComponentRegistry.class,
          undertowDeploymentInfoService.getComponentRegistryInjectedValue());
    } else {
      undertowDeploymentInfoService
          .getComponentRegistryInjectedValue()
          .setValue(new ImmediateValue<>(componentRegistry));
    }

    if (sharedSessionManagerConfig != null) {
      infoBuilder.addDependency(
          deploymentUnit
              .getParent()
              .getServiceName()
              .append(SharedSessionManagerConfig.SHARED_SESSION_MANAGER_SERVICE_NAME),
          SessionManagerFactory.class,
          undertowDeploymentInfoService.getSessionManagerFactoryInjector());
      infoBuilder.addDependency(
          deploymentUnit
              .getParent()
              .getServiceName()
              .append(SharedSessionManagerConfig.SHARED_SESSION_IDENTIFIER_CODEC_SERVICE_NAME),
          SessionIdentifierCodec.class,
          undertowDeploymentInfoService.getSessionIdentifierCodecInjector());
    } else {
      ServiceName sessionManagerFactoryServiceName =
          installSessionManagerFactory(
              serviceTarget, deploymentServiceName, deploymentName, module, metaData);
      infoBuilder.addDependency(
          sessionManagerFactoryServiceName,
          SessionManagerFactory.class,
          undertowDeploymentInfoService.getSessionManagerFactoryInjector());

      ServiceName sessionIdentifierCodecServiceName =
          installSessionIdentifierCodec(
              serviceTarget, deploymentServiceName, deploymentName, metaData);
      infoBuilder.addDependency(
          sessionIdentifierCodecServiceName,
          SessionIdentifierCodec.class,
          undertowDeploymentInfoService.getSessionIdentifierCodecInjector());
    }

    infoBuilder.install();

    final boolean isWebappBundle = deploymentUnit.hasAttachment(Attachments.OSGI_MANIFEST);

    final UndertowDeploymentService service =
        new UndertowDeploymentService(injectionContainer, !isWebappBundle);
    final ServiceBuilder<UndertowDeploymentService> builder =
        serviceTarget
            .addService(deploymentServiceName, service)
            .addDependencies(dependentComponents)
            .addDependency(
                UndertowService.SERVLET_CONTAINER.append(defaultContainer),
                ServletContainerService.class,
                service.getContainer())
            .addDependency(hostServiceName, Host.class, service.getHost())
            .addDependencies(deploymentUnit.getAttachmentList(Attachments.WEB_DEPENDENCIES))
            .addDependency(
                deploymentInfoServiceName,
                DeploymentInfo.class,
                service.getDeploymentInfoInjectedValue());
    // inject the server executor which can be used by the WebDeploymentService for blocking tasks
    // in start/stop
    // of that service
    Services.addServerExecutorDependency(builder, service.getServerExecutorInjector(), false);

    deploymentUnit.addToAttachmentList(
        Attachments.DEPLOYMENT_COMPLETE_SERVICES, deploymentServiceName);

    // adding JACC service
    if (securityEnabled) {
      AbstractSecurityDeployer<WarMetaData> deployer = new WarJACCDeployer();
      JaccService<WarMetaData> jaccService = deployer.deploy(deploymentUnit, jaccContextId);
      if (jaccService != null) {
        final ServiceName jaccServiceName =
            deploymentUnit.getServiceName().append(JaccService.SERVICE_NAME);
        ServiceBuilder<?> jaccBuilder = serviceTarget.addService(jaccServiceName, jaccService);
        if (deploymentUnit.getParent() != null) {
          // add dependency to parent policy
          final DeploymentUnit parentDU = deploymentUnit.getParent();
          jaccBuilder.addDependency(
              parentDU.getServiceName().append(JaccService.SERVICE_NAME),
              PolicyConfiguration.class,
              jaccService.getParentPolicyInjector());
        }
        // add dependency to web deployment service
        jaccBuilder.addDependency(deploymentServiceName);
        jaccBuilder.setInitialMode(Mode.PASSIVE).install();
      }
    }

    // OSGi web applications are activated in {@link WebContextActivationProcessor} according to
    // bundle lifecycle changes
    if (isWebappBundle) {
      UndertowDeploymentService.ContextActivatorImpl activator =
          new UndertowDeploymentService.ContextActivatorImpl(builder.install());
      deploymentUnit.putAttachment(ContextActivator.ATTACHMENT_KEY, activator);
      deploymentUnit.addToAttachmentList(
          Attachments.BUNDLE_ACTIVE_DEPENDENCIES, deploymentServiceName);
    } else {
      builder.install();
    }

    // Process the web related mgmt information
    final DeploymentResourceSupport deploymentResourceSupport =
        deploymentUnit.getAttachment(Attachments.DEPLOYMENT_RESOURCE_SUPPORT);
    final ModelNode node =
        deploymentResourceSupport.getDeploymentSubsystemModel(UndertowExtension.SUBSYSTEM_NAME);
    node.get(DeploymentDefinition.CONTEXT_ROOT.getName()).set("".equals(pathName) ? "/" : pathName);
    node.get(DeploymentDefinition.VIRTUAL_HOST.getName()).set(hostName);
    node.get(DeploymentDefinition.SERVER.getName()).set(serverInstanceName);
    processManagement(deploymentUnit, metaData);
  }
Esempio n. 17
0
 public static ServiceName handlerFileName(final String handlerName) {
   return HANDLER_FILE.append(handlerName);
 }
Esempio n. 18
0
 public static ServiceName handlerName(final String name) {
   return HANDLER.append(name);
 }
Esempio n. 19
0
 public static ServiceName loggerHandlerName(final String loggerName, final String handlerName) {
   return CommonAttributes.ROOT_LOGGER_NAME.equals(loggerName)
       ? ROOT_LOGGER_HANDLER.append(CommonAttributes.ROOT_LOGGER_NAME, handlerName)
       : LOGGER_HANDLER.append(loggerName, handlerName);
 }
Esempio n. 20
0
 public static ServiceName loggerName(final String name) {
   return CommonAttributes.ROOT_LOGGER_NAME.equals(name) ? ROOT_LOGGER : LOGGER.append(name);
 }
Esempio n. 21
0
 private static ServiceName newServiceName(final String name) {
   if (name == null) {
     throw SarLogger.ROOT_LOGGER.nullVar("name");
   }
   return MBEAN_SERVICE_NAME_BASE.append(name);
 }
Esempio n. 22
0
 /**
  * Get the base service name of an application's JNDI namespace.
  *
  * @param app the application name (must not be {@code null})
  * @return the base service name
  */
 public static ServiceName contextServiceNameOfApplication(String app) {
   return APPLICATION_CONTEXT_SERVICE_NAME.append(app);
 }
 public static ServiceName getServiceName(String contextName) {
   ServiceName deploymentServiceName = Services.deploymentUnitName(contextName);
   return SERVICE_NAME_BASE.append(deploymentServiceName.getSimpleName());
 }
Esempio n. 24
0
 public static ServiceName getServiceName(String id) {
   return SERVICE_NAME.append((id != null) ? id : DEFAULT);
 }
Esempio n. 25
0
/** @author John Bailey */
public class ContextNames {

  /** Parent ServiceName for all naming services. */
  public static final ServiceName NAMING = ServiceName.JBOSS.append("naming");
  /** ServiceName for java: namespace */
  public static final ServiceName JAVA_CONTEXT_SERVICE_NAME = NAMING.append("context", "java");
  /** Parent ServiceName for java:comp namespace */
  public static final ServiceName COMPONENT_CONTEXT_SERVICE_NAME =
      JAVA_CONTEXT_SERVICE_NAME.append("comp");
  /** Jndi name for java: namespace */
  public static final JndiName JAVA_CONTEXT_NAME = JndiName.of("java:");

  /** Jndi name for java:jboss namespace */
  public static final JndiName JBOSS_CONTEXT_NAME = JndiName.of("java:jboss");

  /** ServiceName for java:jboss namespace */
  public static final ServiceName JBOSS_CONTEXT_SERVICE_NAME =
      JAVA_CONTEXT_SERVICE_NAME.append("jboss");

  /** Jndi name for java:global namespace */
  public static final JndiName GLOBAL_CONTEXT_NAME = JndiName.of("java:global");

  /** ServiceName for java:global namespace */
  public static final ServiceName GLOBAL_CONTEXT_SERVICE_NAME =
      JAVA_CONTEXT_SERVICE_NAME.append("global");

  /** Jndi name for java:app namespace */
  public static final JndiName APPLICATION_CONTEXT_NAME = JndiName.of("java:app");

  /** Parent ServiceName for java:app namespace */
  public static final ServiceName APPLICATION_CONTEXT_SERVICE_NAME =
      JAVA_CONTEXT_SERVICE_NAME.append("app");

  /** Jndi name for java:module namespace */
  public static final JndiName MODULE_CONTEXT_NAME = JndiName.of("java:module");

  /** Parent ServiceName for java:module namespace */
  public static final ServiceName MODULE_CONTEXT_SERVICE_NAME =
      JAVA_CONTEXT_SERVICE_NAME.append("module");

  /** Jndi name for java:comp namespace */
  public static final JndiName COMPONENT_CONTEXT_NAME = JndiName.of("java:comp");

  /**
   * Get the base service name of a component's JNDI namespace.
   *
   * @param app the application name (must not be {@code null})
   * @param module the module name (must not be {@code null})
   * @param comp the component name (must not be {@code null})
   * @return the base service name
   */
  public static ServiceName contextServiceNameOfComponent(String app, String module, String comp) {
    return COMPONENT_CONTEXT_SERVICE_NAME.append(app, module, comp);
  }

  /**
   * Get the base service name of a module's JNDI namespace.
   *
   * @param app the application name (must not be {@code null})
   * @param module the module name (must not be {@code null})
   * @return the base service name
   */
  public static ServiceName contextServiceNameOfModule(String app, String module) {
    return MODULE_CONTEXT_SERVICE_NAME.append(app, module);
  }

  /**
   * Get the base service name of an application's JNDI namespace.
   *
   * @param app the application name (must not be {@code null})
   * @return the base service name
   */
  public static ServiceName contextServiceNameOfApplication(String app) {
    return APPLICATION_CONTEXT_SERVICE_NAME.append(app);
  }

  /**
   * Get the service name of a context, or {@code null} if there is no service mapping for the
   * context name.
   *
   * @param app the application name
   * @param module the module name
   * @param comp the component name
   * @param context the context to check
   * @return the service name or {@code null} if there is no service
   */
  public static ServiceName serviceNameOfContext(
      String app, String module, String comp, String context) {
    if (context.startsWith("java:")) {
      final String namespace;
      final int i = context.indexOf('/');
      if (i == -1) {
        namespace = context.substring(5);
      } else {
        namespace = context.substring(5, i);
      }
      if (namespace.equals("global")) {
        return GLOBAL_CONTEXT_SERVICE_NAME.append(context.substring(12));
      } else if (namespace.equals("jboss")) {
        return JBOSS_CONTEXT_SERVICE_NAME.append(context.substring(11));
      } else if (namespace.equals("app")) {
        return contextServiceNameOfApplication(app).append(context.substring(9));
      } else if (namespace.equals("module")) {
        return contextServiceNameOfModule(app, module).append(context.substring(12));
      } else if (namespace.equals("comp")) {
        return contextServiceNameOfComponent(app, module, comp).append(context.substring(10));
      } else {
        return JAVA_CONTEXT_SERVICE_NAME.append(context);
      }
    } else {
      return null;
    }
  }

  /**
   * Get the service name of a NamingStore
   *
   * @param app the application name
   * @param module the module name
   * @param comp the component name
   * @param context the context to check
   * @return the service name or {@code null} if there is no service
   */
  public static ServiceName serviceNameOfNamingStore(
      String app, String module, String comp, String context) {
    if (context.startsWith("java:")) {
      final String namespace;
      final int i = context.indexOf('/');
      if (i == -1) {
        namespace = context.substring(5);
      } else {
        namespace = context.substring(5, i);
      }
      if (namespace.equals("global")) {
        return GLOBAL_CONTEXT_SERVICE_NAME;
      } else if (namespace.equals("jboss")) {
        return JBOSS_CONTEXT_SERVICE_NAME;
      } else if (namespace.equals("app")) {
        return contextServiceNameOfApplication(app);
      } else if (namespace.equals("module")) {
        return contextServiceNameOfModule(app, module);
      } else if (namespace.equals("comp")) {
        return contextServiceNameOfComponent(app, module, comp);
      } else {
        return JAVA_CONTEXT_SERVICE_NAME;
      }
    } else {
      return null;
    }
  }

  /**
   * Get the service name of an environment entry
   *
   * @param app the application name
   * @param module the module name
   * @param comp the component name
   * @param useCompNamespace If the component has its own comp namespace
   * @param envEntryName The env entry name
   * @return the service name or {@code null} if there is no service
   */
  public static ServiceName serviceNameOfEnvEntry(
      String app, String module, String comp, boolean useCompNamespace, final String envEntryName) {
    if (envEntryName.startsWith("java:")) {
      if (useCompNamespace) {
        return serviceNameOfContext(app, module, comp, envEntryName);
      } else {
        return serviceNameOfContext(app, module, module, envEntryName);
      }
    } else {
      if (useCompNamespace) {
        return serviceNameOfContext(app, module, comp, "java:comp/env/" + envEntryName);
      } else {
        return serviceNameOfContext(app, module, module, "java:module/env/" + envEntryName);
      }
    }
  }
}
Esempio n. 26
0
  static void installRuntimeServices(
      OperationContext context,
      PathAddress address,
      ModelNode fullModel,
      ServiceVerificationHandler verificationHandler,
      List<ServiceController<?>> controllers)
      throws OperationFailedException {
    String name = address.getLastElement().getValue();

    final String jndiName = getJndiName(fullModel, context);
    final ServiceTarget serviceTarget = context.getServiceTarget();

    final MailSessionConfig config = from(context, fullModel);
    final MailSessionService service = new MailSessionService(config);
    final ServiceName serviceName = MAIL_SESSION_SERVICE_NAME.append(name);
    final ServiceBuilder<?> mailSessionBuilder = serviceTarget.addService(serviceName, service);
    addOutboundSocketDependency(service, mailSessionBuilder, config.getImapServer());
    addOutboundSocketDependency(service, mailSessionBuilder, config.getPop3Server());
    addOutboundSocketDependency(service, mailSessionBuilder, config.getSmtpServer());
    for (CustomServerConfig server : config.getCustomServers()) {
      if (server.getOutgoingSocketBinding() != null) {
        addOutboundSocketDependency(service, mailSessionBuilder, server);
      }
    }

    final ManagedReferenceFactory valueManagedReferenceFactory =
        new MailSessionManagedReferenceFactory(service);
    final ContextNames.BindInfo bindInfo = ContextNames.bindInfoFor(jndiName);
    final BinderService binderService = new BinderService(bindInfo.getBindName());
    final ServiceBuilder<?> binderBuilder =
        serviceTarget
            .addService(bindInfo.getBinderServiceName(), binderService)
            .addInjection(binderService.getManagedObjectInjector(), valueManagedReferenceFactory)
            .addDependency(
                bindInfo.getParentContextServiceName(),
                ServiceBasedNamingStore.class,
                binderService.getNamingStoreInjector())
            .addListener(
                new AbstractServiceListener<Object>() {
                  public void transition(
                      final ServiceController<? extends Object> controller,
                      final ServiceController.Transition transition) {
                    switch (transition) {
                      case STARTING_to_UP:
                        {
                          MailLogger.ROOT_LOGGER.boundMailSession(jndiName);
                          break;
                        }
                      case START_REQUESTED_to_DOWN:
                        {
                          MailLogger.ROOT_LOGGER.unboundMailSession(jndiName);
                          break;
                        }
                      case REMOVING_to_REMOVED:
                        {
                          MailLogger.ROOT_LOGGER.removedMailSession(jndiName);
                          break;
                        }
                    }
                  }
                });

    mailSessionBuilder
        .setInitialMode(ServiceController.Mode.ACTIVE)
        .addListener(verificationHandler);
    binderBuilder.setInitialMode(ServiceController.Mode.ACTIVE).addListener(verificationHandler);
    controllers.add(mailSessionBuilder.install());
    controllers.add(binderBuilder.install());
  }
/**
 * Service that manages an EJBClientContext
 *
 * @author Stuart Douglas
 */
public class DefaultEjbClientContextService implements Service<EJBClientContext> {

  private static final Logger logger = Logger.getLogger(DefaultEjbClientContextService.class);

  /** The base service name for these services */
  public static final ServiceName BASE_SERVICE_NAME =
      ServiceName.JBOSS.append("ejb3", "ejbClientContext");

  /** The default service name. There will always be a service registered under this name */
  public static final ServiceName DEFAULT_SERVICE_NAME = BASE_SERVICE_NAME.append("default");

  // setup the EJB client context selector in a static block so that the service restart
  // doesn't run into trouble while resetting a selector, since the ability to switch the
  // selector will be locked https://issues.jboss.org/browse/AS7-2998
  static {
    // setup the selector
    AccessController.doPrivileged(new SetSelectorAction(TCCLEJBClientContextSelector.INSTANCE));
  }

  private final InjectedValue<TCCLEJBClientContextSelectorService> tcclEJBClientContextSelector =
      new InjectedValue<TCCLEJBClientContextSelectorService>();

  private final InjectedValue<LocalEjbReceiver> defaultLocalEJBReceiver =
      new InjectedValue<LocalEjbReceiver>();

  /** The client context */
  private volatile EJBClientContext context;

  private final boolean lockSelectorOnStart;

  /**
   * @param lockEJBClientContextSelectorOnStart True if the EJB client context selector should be
   *     locked on start of this service. False otherwise.
   */
  public DefaultEjbClientContextService(final boolean lockEJBClientContextSelectorOnStart) {
    this.lockSelectorOnStart = lockEJBClientContextSelectorOnStart;
  }

  @Override
  public synchronized void start(final StartContext context) throws StartException {
    final EJBClientContext clientContext =
        EJBClientContext.create(new LocalOnlyEjbClientConfiguration());
    // register the default local EJB receiver (if present - app clients don't have local EJB
    // receivers)
    final LocalEjbReceiver localEjbReceiver = this.defaultLocalEJBReceiver.getOptionalValue();
    if (localEjbReceiver != null) {
      clientContext.registerEJBReceiver(localEjbReceiver);
    }
    this.context = clientContext;
    if (this.lockSelectorOnStart) {
      // lock the EJB client context selector
      AccessController.doPrivileged(new LockSelectorAction());
    }

    // the EJBClientContext selector is set to TCCLEJBClientContextSelector and is *locked* once
    // (in a static block of this service) so that restarting this service will not cause failures
    // related
    // to resetting the selector. The TCCLEJBClientContextSelector is backed by a
    // TCCLEJBClientContextSelectorService
    // which is what we set here during the service start, so that the selector has the correct
    // service to return the
    // EJBClientContext. @see https://issues.jboss.org/browse/AS7-2998 for details
    TCCLEJBClientContextSelector.INSTANCE.setup(
        this.tcclEJBClientContextSelector.getValue(), this.context);
  }

  @Override
  public synchronized void stop(final StopContext context) {
    this.context = null;
    TCCLEJBClientContextSelector.INSTANCE.destroy();
  }

  @Override
  public EJBClientContext getValue() throws IllegalStateException, IllegalArgumentException {
    return context;
  }

  public Injector<TCCLEJBClientContextSelectorService>
      getTCCLBasedEJBClientContextSelectorInjector() {
    return this.tcclEJBClientContextSelector;
  }

  public Injector<LocalEjbReceiver> getDefaultLocalEJBReceiverInjector() {
    return this.defaultLocalEJBReceiver;
  }

  private static final class SetSelectorAction
      implements PrivilegedAction<ContextSelector<EJBClientContext>> {

    private final ContextSelector<EJBClientContext> selector;

    private SetSelectorAction(final ContextSelector<EJBClientContext> selector) {
      this.selector = selector;
    }

    @Override
    public ContextSelector<EJBClientContext> run() {
      return EJBClientContext.setSelector(selector);
    }
  }

  private static final class LockSelectorAction implements PrivilegedAction<Void> {
    @Override
    public Void run() {
      EJBClientContext.lockSelector();
      return null;
    }
  }

  /**
   * A {@link EJBClientConfiguration} which is applicable only for a {@link EJBClientContext}
   * consisting of just the {@link LocalEjbReceiver}. i.e. this client configuration cannot be used
   * for setting up connections to remote servers
   */
  class LocalOnlyEjbClientConfiguration implements EJBClientConfiguration {

    private final DeploymentNodeSelector localPreferringDeploymentNodeSelector =
        new LocalEJBReceiverPreferringDeploymentNodeSelector();

    @Override
    public String getEndpointName() {
      // This client configuration will *not* be used to create endpoints
      return null;
    }

    @Override
    public OptionMap getEndpointCreationOptions() {
      // This client configuration will *not* be used to create endpoints
      return OptionMap.EMPTY;
    }

    @Override
    public OptionMap getRemoteConnectionProviderCreationOptions() {
      // This client configuration will *not* be used to register connection providers
      return OptionMap.EMPTY;
    }

    @Override
    public CallbackHandler getCallbackHandler() {
      // This client configuration is not applicable for registering remote connections
      return null;
    }

    @Override
    public Iterator<RemotingConnectionConfiguration> getConnectionConfigurations() {
      // This client configuration will *not* be used for auto creating connections to remote
      // servers.
      return Collections.EMPTY_SET.iterator();
    }

    @Override
    public Iterator<ClusterConfiguration> getClusterConfigurations() {
      return Collections.EMPTY_SET.iterator();
    }

    @Override
    public ClusterConfiguration getClusterConfiguration(String nodeName) {
      return null;
    }

    @Override
    public long getInvocationTimeout() {
      return 0;
    }

    @Override
    public long getReconnectTasksTimeout() {
      return 0;
    }

    @Override
    public DeploymentNodeSelector getDeploymentNodeSelector() {
      return this.localPreferringDeploymentNodeSelector;
    }
  }
}
Esempio n. 28
0
 /**
  * Get the base service name of a component's JNDI namespace.
  *
  * @param app the application name (must not be {@code null})
  * @param module the module name (must not be {@code null})
  * @param comp the component name (must not be {@code null})
  * @return the base service name
  */
 public static ServiceName contextServiceNameOfComponent(String app, String module, String comp) {
   return COMPONENT_CONTEXT_SERVICE_NAME.append(app, module, comp);
 }
 public static ServiceName getServiceName(ContextNames.BindInfo bindInfo) {
   return SERVICE_NAME_BASE.append(bindInfo.getBinderServiceName().getCanonicalName());
 }
Esempio n. 30
0
 /**
  * Get the base service name of a module's JNDI namespace.
  *
  * @param app the application name (must not be {@code null})
  * @param module the module name (must not be {@code null})
  * @return the base service name
  */
 public static ServiceName contextServiceNameOfModule(String app, String module) {
   return MODULE_CONTEXT_SERVICE_NAME.append(app, module);
 }