Example #1
0
    public void configure(
        final DeploymentPhaseContext context,
        final ComponentConfiguration componentConfiguration,
        final ViewDescription description,
        final ViewConfiguration configuration)
        throws DeploymentUnitProcessingException {
      // Create method indexes
      final DeploymentReflectionIndex reflectionIndex =
          context.getDeploymentUnit().getAttachment(REFLECTION_INDEX);
      final List<Method> methods = configuration.getProxyFactory().getCachedMethods();
      for (final Method method : methods) {
        MethodIdentifier methodIdentifier = MethodIdentifier.getIdentifierForMethod(method);
        Method componentMethod =
            ClassReflectionIndexUtil.findMethod(
                reflectionIndex, componentConfiguration.getComponentClass(), methodIdentifier);

        if (componentMethod == null
            && method.getDeclaringClass().isInterface()
            && (method.getModifiers() & (ABSTRACT | PUBLIC | STATIC)) == PUBLIC) {
          // no component method and the interface method is defaulted, so we really do want to
          // invoke on the interface method
          componentMethod = method;
        }
        if (componentMethod != null) {

          if ((BRIDGE & componentMethod.getModifiers()) != 0) {
            Method other =
                findRealMethodForBridgeMethod(
                    componentMethod, componentConfiguration, reflectionIndex, methodIdentifier);
            // try and find the non-bridge method to delegate to
            if (other != null) {
              componentMethod = other;
            }
          }

          configuration.addViewInterceptor(
              method,
              new ImmediateInterceptorFactory(new ComponentDispatcherInterceptor(componentMethod)),
              InterceptorOrder.View.COMPONENT_DISPATCHER);
          configuration.addClientInterceptor(
              method,
              CLIENT_DISPATCHER_INTERCEPTOR_FACTORY,
              InterceptorOrder.Client.CLIENT_DISPATCHER);
        }
      }

      configuration.addClientPostConstructInterceptor(
          Interceptors.getTerminalInterceptorFactory(),
          InterceptorOrder.ClientPostConstruct.TERMINAL_INTERCEPTOR);
      configuration.addClientPreDestroyInterceptor(
          Interceptors.getTerminalInterceptorFactory(),
          InterceptorOrder.ClientPreDestroy.TERMINAL_INTERCEPTOR);
    }
Example #2
0
    public void configure(
        final DeploymentPhaseContext context,
        final ComponentConfiguration componentConfiguration,
        final ViewDescription description,
        final ViewConfiguration configuration)
        throws DeploymentUnitProcessingException {
      // Create method indexes
      final DeploymentReflectionIndex reflectionIndex =
          context.getDeploymentUnit().getAttachment(REFLECTION_INDEX);
      final List<Method> methods = configuration.getProxyFactory().getCachedMethods();
      for (final Method method : methods) {
        MethodIdentifier methodIdentifier = MethodIdentifier.getIdentifierForMethod(method);
        Method componentMethod =
            ClassReflectionIndexUtil.findMethod(
                reflectionIndex, componentConfiguration.getComponentClass(), methodIdentifier);

        if (componentMethod != null) {

          if ((BRIDGE & componentMethod.getModifiers()) != 0) {
            Collection<Method> otherMethods =
                ClassReflectionIndexUtil.findMethods(
                    reflectionIndex,
                    reflectionIndex.getClassIndex(componentConfiguration.getComponentClass()),
                    methodIdentifier.getName(),
                    methodIdentifier.getParameterTypes());
            // try and find the non-bridge method to delegate to
            for (final Method other : otherMethods) {
              if ((BRIDGE & other.getModifiers()) == 0) {
                componentMethod = other;
                break;
              }
            }
          }

          configuration.addViewInterceptor(
              method,
              new ImmediateInterceptorFactory(new ComponentDispatcherInterceptor(componentMethod)),
              InterceptorOrder.View.COMPONENT_DISPATCHER);
          configuration.addClientInterceptor(
              method,
              CLIENT_DISPATCHER_INTERCEPTOR_FACTORY,
              InterceptorOrder.Client.CLIENT_DISPATCHER);
        }
      }

      configuration.addClientPostConstructInterceptor(
          Interceptors.getTerminalInterceptorFactory(),
          InterceptorOrder.ClientPostConstruct.TERMINAL_INTERCEPTOR);
      configuration.addClientPreDestroyInterceptor(
          Interceptors.getTerminalInterceptorFactory(),
          InterceptorOrder.ClientPreDestroy.TERMINAL_INTERCEPTOR);
    }
 @Override
 public Object processInvocation(final InterceptorContext context) throws Exception {
   final Object instance = context.getPrivateData(ComponentInstance.class).getInstance();
   try {
     return method.invoke(instance, context.getPrivateData(PARAMETERS_KEY));
   } catch (InvocationTargetException e) {
     throw Interceptors.rethrow(e.getCause());
   }
 }
Example #4
0
 ViewService(final ViewConfiguration viewConfiguration) {
   viewClass = viewConfiguration.getViewClass();
   final ProxyFactory<?> proxyFactory = viewConfiguration.getProxyFactory();
   this.proxyFactory = proxyFactory;
   final Method[] methods = proxyFactory.getCachedMethods();
   final int methodCount = methods.length;
   viewPostConstruct =
       Interceptors.getChainedInterceptorFactory(
           viewConfiguration.getViewPostConstructInterceptors());
   viewPreDestroy =
       Interceptors.getChainedInterceptorFactory(
           viewConfiguration.getViewPreDestroyInterceptors());
   clientPostConstruct =
       Interceptors.getChainedInterceptorFactory(
           viewConfiguration.getClientPostConstructInterceptors());
   clientPreDestroy =
       Interceptors.getChainedInterceptorFactory(
           viewConfiguration.getClientPreDestroyInterceptors());
   final IdentityHashMap<Method, InterceptorFactory> viewInterceptorFactories =
       new IdentityHashMap<Method, InterceptorFactory>(methodCount);
   final IdentityHashMap<Method, InterceptorFactory> clientInterceptorFactories =
       new IdentityHashMap<Method, InterceptorFactory>(methodCount);
   for (Method method : methods) {
     if (method.getName().equals("finalize") && method.getParameterTypes().length == 0) {
       viewInterceptorFactories.put(method, DESTROY_INTERCEPTOR);
     } else {
       viewInterceptorFactories.put(
           method,
           Interceptors.getChainedInterceptorFactory(
               viewConfiguration.getViewInterceptorDeque(method)));
       clientInterceptorFactories.put(
           method,
           Interceptors.getChainedInterceptorFactory(
               viewConfiguration.getClientInterceptorDeque(method)));
     }
   }
   this.viewInterceptorFactories = viewInterceptorFactories;
   this.clientInterceptorFactories = clientInterceptorFactories;
   allowedMethods = Collections.unmodifiableSet(viewInterceptorFactories.keySet());
 }
  /**
   * Construct a new instance.
   *
   * @param componentConfiguration the component configuration
   */
  public EJBComponentCreateService(
      final ComponentConfiguration componentConfiguration,
      final ApplicationExceptions applicationExceptions) {
    super(componentConfiguration);

    this.applicationExceptions = applicationExceptions;
    final EJBComponentDescription ejbComponentDescription =
        (EJBComponentDescription) componentConfiguration.getComponentDescription();
    this.transactionManagementType = ejbComponentDescription.getTransactionManagementType();

    this.timerService = ejbComponentDescription.getTimerService();
    this.policyContextID = ejbComponentDescription.getPolicyContextID();

    // CMTTx
    if (transactionManagementType.equals(TransactionManagementType.CONTAINER)) {
      this.txAttrs = new HashMap<MethodTransactionAttributeKey, TransactionAttributeType>();
      this.txTimeouts = new HashMap<MethodTransactionAttributeKey, Integer>();
    } else {
      this.txAttrs = null;
      this.txTimeouts = null;
    }
    // Setup the security metadata for the bean
    this.securityMetaData = new EJBSecurityMetaData(componentConfiguration);

    if (ejbComponentDescription.isTimerServiceRequired()) {
      Map<Method, InterceptorFactory> timeoutInterceptors =
          new IdentityHashMap<Method, InterceptorFactory>();
      for (Method method : componentConfiguration.getDefinedComponentMethods()) {
        if ((ejbComponentDescription.getTimeoutMethod() != null
                && ejbComponentDescription.getTimeoutMethod().equals(method))
            || ejbComponentDescription.getScheduleMethods().containsKey(method)) {
          final InterceptorFactory interceptorFactory =
              Interceptors.getChainedInterceptorFactory(
                  componentConfiguration.getAroundTimeoutInterceptors(method));
          timeoutInterceptors.put(method, interceptorFactory);
        }
      }
      this.timeoutInterceptors = timeoutInterceptors;
    } else {
      timeoutInterceptors = Collections.emptyMap();
    }

    List<ViewConfiguration> views = componentConfiguration.getViews();
    if (views != null) {
      for (ViewConfiguration view : views) {
        // TODO: Move this into a configurator
        final EJBViewConfiguration ejbView = (EJBViewConfiguration) view;
        final MethodIntf viewType = ejbView.getMethodIntf();
        for (Method method : view.getProxyFactory().getCachedMethods()) {
          // TODO: proxy factory exposes non-public methods, is this a bug in the no-interface view?
          if (!Modifier.isPublic(method.getModifiers())) continue;
          final Method componentMethod =
              getComponentMethod(
                  componentConfiguration, method.getName(), method.getParameterTypes());
          if (componentMethod != null) {
            this.processTxAttr(ejbComponentDescription, viewType, componentMethod);
          } else {
            this.processTxAttr(ejbComponentDescription, viewType, method);
          }
        }
      }
    }

    this.timeoutMethod = ejbComponentDescription.getTimeoutMethod();

    // FIXME: TODO: a temporary measure until EJBTHREE-2120 is fully resolved, let's create tx
    // attribute map
    // for the component methods. Once the issue is resolved, we should get rid of this block and
    // just rely on setting
    // up the tx attributes only for the views exposed by this component
    // AS7-899: We only want to process public methods of the proper sub-class.
    // (getDefinedComponentMethods returns all in random order)
    // TODO: use ClassReflectionIndex (low prio, because we store the result without class name)
    // (which is a bug: AS7-905)
    Set<Method> lifeCycle = new HashSet<>(componentConfiguration.getLifecycleMethods());
    for (Method method : componentConfiguration.getComponentClass().getMethods()) {
      this.processTxAttr(ejbComponentDescription, MethodIntf.BEAN, method);
      lifeCycle.remove(method);
    }
    // now handle non-public lifecycle methods declared on the bean class itself
    // see WFLY-4127
    for (Method method : lifeCycle) {
      if (method.getDeclaringClass().equals(componentConfiguration.getComponentClass())) {
        this.processTxAttr(ejbComponentDescription, MethodIntf.BEAN, method);
      }
    }

    final HashMap<String, ServiceName> viewServices = new HashMap<String, ServiceName>();
    for (ViewDescription view : componentConfiguration.getComponentDescription().getViews()) {
      viewServices.put(view.getViewClassName(), view.getServiceName());
    }
    this.viewServices = viewServices;
    final EjbHomeViewDescription localHome = ejbComponentDescription.getEjbLocalHomeView();
    this.ejbLocalHome =
        localHome == null ? null : ejbComponentDescription.getEjbLocalHomeView().getServiceName();
    final EjbHomeViewDescription home = ejbComponentDescription.getEjbHomeView();
    this.ejbHome = home == null ? null : home.getServiceName();
    final EJBViewDescription ejbObject = ejbComponentDescription.getEjbRemoteView();
    this.ejbObject = ejbObject == null ? null : ejbObject.getServiceName();
    final EJBViewDescription ejbLocalObject = ejbComponentDescription.getEjbLocalView();
    this.ejbLocalObject = ejbLocalObject == null ? null : ejbLocalObject.getServiceName();
    this.applicationName = componentConfiguration.getApplicationName();
    this.earApplicationName =
        componentConfiguration
            .getComponentDescription()
            .getModuleDescription()
            .getEarApplicationName();
    this.moduleName = componentConfiguration.getModuleName();
    this.distinctName =
        componentConfiguration.getComponentDescription().getModuleDescription().getDistinctName();
    this.shutDownInterceptorFactory = ejbComponentDescription.getShutDownInterceptorFactory();
  }
  /**
   * Construct a new instance.
   *
   * @param componentConfiguration the component configuration
   */
  public StatefulSessionComponentCreateService(
      final ComponentConfiguration componentConfiguration,
      final ApplicationExceptions ejbJarConfiguration) {
    super(componentConfiguration, ejbJarConfiguration);

    final StatefulComponentDescription componentDescription =
        (StatefulComponentDescription) componentConfiguration.getComponentDescription();
    final ClassLoader classLoader = componentConfiguration.getModuleClassLoader();
    final InterceptorFactory tcclInterceptorFactory =
        new ImmediateInterceptorFactory(new ContextClassLoaderInterceptor(classLoader));
    final InterceptorFactory namespaceContextInterceptorFactory =
        componentConfiguration.getNamespaceContextInterceptorFactory();

    this.afterBeginMethod = componentDescription.getAfterBegin();
    this.afterBegin =
        (this.afterBeginMethod != null)
            ? Interceptors.getChainedInterceptorFactory(
                tcclInterceptorFactory,
                namespaceContextInterceptorFactory,
                CurrentInvocationContextInterceptor.FACTORY,
                invokeMethodOnTarget(this.afterBeginMethod))
            : null;
    this.afterCompletionMethod = componentDescription.getAfterCompletion();
    this.afterCompletion =
        (this.afterCompletionMethod != null)
            ? Interceptors.getChainedInterceptorFactory(
                tcclInterceptorFactory,
                namespaceContextInterceptorFactory,
                CurrentInvocationContextInterceptor.FACTORY,
                invokeMethodOnTarget(this.afterCompletionMethod))
            : null;
    this.beforeCompletionMethod = componentDescription.getBeforeCompletion();
    this.beforeCompletion =
        (this.beforeCompletionMethod != null)
            ? Interceptors.getChainedInterceptorFactory(
                tcclInterceptorFactory,
                namespaceContextInterceptorFactory,
                CurrentInvocationContextInterceptor.FACTORY,
                invokeMethodOnTarget(this.beforeCompletionMethod))
            : null;
    this.prePassivate =
        Interceptors.getChainedInterceptorFactory(
            componentConfiguration.getPrePassivateInterceptors());
    this.postActivate =
        Interceptors.getChainedInterceptorFactory(
            componentConfiguration.getPostActivateInterceptors());
    this.statefulTimeout = componentDescription.getStatefulTimeout();
    // the interceptor chain for EJB e.x remove methods
    this.ejb2XRemoveMethod =
        Interceptors.getChainedInterceptorFactory(
            StatefulSessionSynchronizationInterceptor.factory(
                componentDescription.getTransactionManagementType()),
            new ImmediateInterceptorFactory(new StatefulRemoveInterceptor(false)),
            Interceptors.getTerminalInterceptorFactory());
    this.cache = componentDescription.getCache();
    this.loader = componentConfiguration.getModuleClassLoader();
    MarshallingConfiguration marshallingConfiguration = new MarshallingConfiguration();
    marshallingConfiguration.setClassResolver(
        ModularClassResolver.getInstance(componentConfiguration.getModuleLoader()));
    marshallingConfiguration.setSerializabilityChecker(
        new StatefulSessionBeanSerializabilityChecker(componentConfiguration.getComponentClass()));
    marshallingConfiguration.setClassTable(new StatefulSessionBeanClassTable());
    // ObjectTable which handles serialization of EJB proxies
    marshallingConfiguration.setObjectTable(new EJBClientContextIdentifierObjectTable());
    this.marshallingConfigurations =
        Collections.singletonMap(CURRENT_MARSHALLING_VERSION, marshallingConfiguration);
    this.serializableInterceptorContextKeys = componentConfiguration.getInterceptorContextKeys();
    this.passivationCapable = componentDescription.isPassivationApplicable();
  }
  @Override
  public void configure(
      final DeploymentPhaseContext context,
      final ComponentConfiguration componentConfiguration,
      final ViewDescription description,
      final ViewConfiguration configuration)
      throws DeploymentUnitProcessingException {
    // note that we don't have to handle all methods on the EJBObject, as some are handled client
    // side
    final DeploymentReflectionIndex index =
        context.getDeploymentUnit().getAttachment(Attachments.REFLECTION_INDEX);
    for (final Method method : configuration.getProxyFactory().getCachedMethods()) {

      if (method.getName().equals("getPrimaryKey") && method.getParameterTypes().length == 0) {
        configuration.addClientInterceptor(
            method,
            ViewDescription.CLIENT_DISPATCHER_INTERCEPTOR_FACTORY,
            InterceptorOrder.Client.CLIENT_DISPATCHER);
        configuration.addViewInterceptor(
            method, PRIMARY_KEY_INTERCEPTOR, InterceptorOrder.View.COMPONENT_DISPATCHER);
      } else if (method.getName().equals("remove") && method.getParameterTypes().length == 0) {
        handleRemoveMethod(componentConfiguration, configuration, index, method);

      } else if (method.getName().equals("getEJBLocalHome")
          && method.getParameterTypes().length == 0) {
        configuration.addClientInterceptor(
            method,
            ViewDescription.CLIENT_DISPATCHER_INTERCEPTOR_FACTORY,
            InterceptorOrder.Client.CLIENT_DISPATCHER);
        final GetHomeInterceptorFactory factory = new GetHomeInterceptorFactory();
        configuration.addViewInterceptor(
            method, factory, InterceptorOrder.View.COMPONENT_DISPATCHER);
        final SessionBeanComponentDescription componentDescription =
            (SessionBeanComponentDescription) componentConfiguration.getComponentDescription();
        componentConfiguration
            .getStartDependencies()
            .add(
                new DependencyConfigurator<ComponentStartService>() {
                  @Override
                  public void configureDependency(
                      final ServiceBuilder<?> serviceBuilder, final ComponentStartService service)
                      throws DeploymentUnitProcessingException {
                    EjbHomeViewDescription ejbLocalHomeView =
                        componentDescription.getEjbLocalHomeView();
                    if (ejbLocalHomeView == null) {
                      throw EjbLogger.ROOT_LOGGER.beanLocalHomeInterfaceIsNull(
                          componentDescription.getComponentName());
                    }
                    serviceBuilder.addDependency(
                        ejbLocalHomeView.getServiceName(),
                        ComponentView.class,
                        factory.getViewToCreate());
                  }
                });
      } else if (method.getName().equals("getEJBHome") && method.getParameterTypes().length == 0) {
        configuration.addClientInterceptor(
            method,
            ViewDescription.CLIENT_DISPATCHER_INTERCEPTOR_FACTORY,
            InterceptorOrder.Client.CLIENT_DISPATCHER);
        final GetHomeInterceptorFactory factory = new GetHomeInterceptorFactory();
        configuration.addViewInterceptor(
            method, factory, InterceptorOrder.View.COMPONENT_DISPATCHER);
        final SessionBeanComponentDescription componentDescription =
            (SessionBeanComponentDescription) componentConfiguration.getComponentDescription();
        componentConfiguration
            .getStartDependencies()
            .add(
                new DependencyConfigurator<ComponentStartService>() {
                  @Override
                  public void configureDependency(
                      final ServiceBuilder<?> serviceBuilder, final ComponentStartService service)
                      throws DeploymentUnitProcessingException {
                    EjbHomeViewDescription ejbHomeView = componentDescription.getEjbHomeView();
                    if (ejbHomeView == null) {
                      throw EjbLogger.ROOT_LOGGER.beanHomeInterfaceIsNull(
                          componentDescription.getComponentName());
                    }
                    serviceBuilder.addDependency(
                        ejbHomeView.getServiceName(),
                        ComponentView.class,
                        factory.getViewToCreate());
                  }
                });
      } else if (method.getName().equals("getHandle") && method.getParameterTypes().length == 0) {
        // ignore, handled client side
      } else if (method.getName().equals("isIdentical")
          && method.getParameterTypes().length == 1
          && (method.getParameterTypes()[0].equals(EJBObject.class)
              || method.getParameterTypes()[0].equals(EJBLocalObject.class))) {

        handleIsIdenticalMethod(componentConfiguration, configuration, index, method);
      } else {
        final Method componentMethod =
            ClassReflectionIndexUtil.findMethod(
                index,
                componentConfiguration.getComponentClass(),
                MethodIdentifier.getIdentifierForMethod(method));

        if (componentMethod != null) {
          if (!Modifier.isPublic(componentMethod.getModifiers())) {
            throw EjbLogger.ROOT_LOGGER.ejbBusinessMethodMustBePublic(componentMethod);
          }
          configuration.addViewInterceptor(
              method,
              new ImmediateInterceptorFactory(new ComponentDispatcherInterceptor(componentMethod)),
              InterceptorOrder.View.COMPONENT_DISPATCHER);
          configuration.addClientInterceptor(
              method,
              ViewDescription.CLIENT_DISPATCHER_INTERCEPTOR_FACTORY,
              InterceptorOrder.Client.CLIENT_DISPATCHER);
        } else if (method.getDeclaringClass() != Object.class
            && method.getDeclaringClass() != WriteReplaceInterface.class) {
          throw EjbLogger.ROOT_LOGGER.couldNotFindViewMethodOnEjb(
              method, description.getViewClassName(), componentConfiguration.getComponentName());
        }
      }
    }

    configuration.addClientPostConstructInterceptor(
        Interceptors.getTerminalInterceptorFactory(),
        InterceptorOrder.ClientPostConstruct.TERMINAL_INTERCEPTOR);
    configuration.addClientPreDestroyInterceptor(
        Interceptors.getTerminalInterceptorFactory(),
        InterceptorOrder.ClientPreDestroy.TERMINAL_INTERCEPTOR);
  }