private InjectionAwareInstanceProvider(
     final InstanceProvider delegate, final Endpoint endpoint, final DeploymentUnit unit) {
   this.delegate = delegate;
   endpointName = endpoint.getShortName();
   endpointClass = endpoint.getTargetBeanName();
   componentPrefix = unit.getServiceName().append("component");
 }
  @Override
  public void handleMessage(SoapMessage msg) throws Fault {
    Endpoint ep = msg.getExchange().get(Endpoint.class);
    sdc.set(ep.getSecurityDomainContext());
    try {
      SecurityToken token = msg.get(SecurityToken.class);
      SecurityContext context = msg.get(SecurityContext.class);
      if (token == null || context == null || context.getUserPrincipal() == null) {
        super.handleMessage(msg);
        return;
      }
      UsernameToken ut = (UsernameToken) token;

      Subject subject =
          createSubject(
              ut.getName(), ut.getPassword(), ut.isHashed(), ut.getNonce(), ut.getCreatedTime());

      SecurityContext sc = doCreateSecurityContext(context.getUserPrincipal(), subject);
      msg.put(SecurityContext.class, sc);
    } finally {
      if (sdc != null) {
        sdc.remove();
      }
    }
  }
 private void setInjectionAwareInstanceProvider(final Endpoint ep) {
   final InstanceProvider stackInstanceProvider = ep.getInstanceProvider();
   final DeploymentUnit unit = ep.getService().getDeployment().getAttachment(DeploymentUnit.class);
   final InstanceProvider injectionAwareInstanceProvider =
       new InjectionAwareInstanceProvider(stackInstanceProvider, ep, unit);
   ep.setInstanceProvider(injectionAwareInstanceProvider);
 }
  /**
   * Creates new Http Web Service endpoint.
   *
   * @param endpointClass endpoint class name
   * @param endpointName endpoint name
   * @param dep deployment
   * @return WS endpoint
   */
  protected final Endpoint newHttpEndpoint(
      final String endpointClass, final String endpointName, final Deployment dep) {
    if (endpointName == null) throw MESSAGES.nullEndpointName();
    if (endpointClass == null) throw MESSAGES.nullEndpointClass();

    final Endpoint endpoint = this.deploymentModelFactory.newHttpEndpoint(endpointClass);
    endpoint.setShortName(endpointName);
    endpoint.setType(endpointType);
    dep.getService().addEndpoint(endpoint);

    return endpoint;
  }
 @Override
 public void stop(final StopContext context) {
   ROOT_LOGGER.stopping(name);
   endpoint.setSecurityDomainContext(null);
   if (hasWebservicesMD(endpoint)) {
     pclWebAppControllerValue.getValue().decrementUsers();
   }
   endpointRegistryValue.getValue().unregister(endpoint);
   final List<RecordProcessor> processors = endpoint.getRecordProcessors();
   for (final RecordProcessor processor : processors) {
     unregisterRecordProcessor(processor, endpoint);
   }
 }
 @Override
 public void start(final StartContext context) throws StartException {
   ROOT_LOGGER.starting(name);
   endpoint.setSecurityDomainContext(
       new SecurityDomainContextAdaptor(securityDomainContextValue.getValue()));
   if (hasWebservicesMD(
       endpoint)) { // basically JAX-RPC deployments require the PortComponentLinkServlet to be
                    // available
     pclWebAppControllerValue.getValue().incrementUsers();
   }
   final List<RecordProcessor> processors = endpoint.getRecordProcessors();
   for (final RecordProcessor processor : processors) {
     registerRecordProcessor(processor, endpoint);
   }
   endpointRegistryValue.getValue().register(endpoint);
 }
 public static void install(
     final ServiceTarget serviceTarget, final Endpoint endpoint, final DeploymentUnit unit) {
   final ServiceName serviceName = getServiceName(unit, endpoint.getShortName());
   final EndpointService service = new EndpointService(endpoint, serviceName);
   final ServiceBuilder<Endpoint> builder = serviceTarget.addService(serviceName, service);
   builder.addDependency(
       DependencyType.REQUIRED,
       SecurityDomainService.SERVICE_NAME.append(getDeploymentSecurityDomainName(endpoint)),
       SecurityDomainContext.class,
       service.getSecurityDomainContextInjector());
   builder.addDependency(
       DependencyType.REQUIRED,
       WSServices.REGISTRY_SERVICE,
       EndpointRegistry.class,
       service.getEndpointRegistryInjector());
   builder.addDependency(
       DependencyType.REQUIRED,
       WSServices.PORT_COMPONENT_LINK_SERVICE,
       WebAppController.class,
       service.getPclWebAppControllerInjector());
   builder.addDependency(
       DependencyType.OPTIONAL,
       MBEAN_SERVER_NAME,
       MBeanServer.class,
       service.getMBeanServerInjector());
   builder.setInitialMode(Mode.ACTIVE);
   builder.install();
 }
 private static String getDeploymentSecurityDomainName(final Endpoint ep) {
   JBossWebMetaData metadata =
       ep.getService().getDeployment().getAttachment(JBossWebMetaData.class);
   String metaDataSecurityDomain = metadata != null ? metadata.getSecurityDomain() : null;
   return metaDataSecurityDomain == null
       ? SecurityConstants.DEFAULT_APPLICATION_POLICY
       : SecurityUtil.unprefixSecurityDomain(metaDataSecurityDomain.trim());
 }
 private void unregisterRecordProcessor(final RecordProcessor processor, final Endpoint ep) {
   MBeanServer mbeanServer = mBeanServerValue.getValue();
   if (mbeanServer != null) {
     try {
       mbeanServer.unregisterMBean(
           ObjectNameFactory.create(ep.getName() + ",recordProcessor=" + processor.getName()));
     } catch (final JMException e) {
       ROOT_LOGGER.cannotUnregisterRecordProcessor();
     }
   } else {
     ROOT_LOGGER.mBeanServerNotAvailable(processor);
   }
 }
示例#10
0
 private void registerRecordProcessor(final RecordProcessor processor, final Endpoint ep) {
   MBeanServer mbeanServer = mBeanServerValue.getValue();
   if (mbeanServer != null) {
     try {
       mbeanServer.registerMBean(
           processor,
           ObjectNameFactory.create(ep.getName() + ",recordProcessor=" + processor.getName()));
     } catch (final JMException ex) {
       ROOT_LOGGER.trace(
           "Cannot register endpoint with JMX server, trying with the default ManagedRecordProcessor: "
               + ex.getMessage());
       try {
         mbeanServer.registerMBean(
             new ManagedRecordProcessor(processor),
             ObjectNameFactory.create(ep.getName() + ",recordProcessor=" + processor.getName()));
       } catch (final JMException e) {
         ROOT_LOGGER.cannotRegisterRecordProcessor();
       }
     }
   } else {
     ROOT_LOGGER.mBeanServerNotAvailable(processor);
   }
 }
  /**
   * Invokes WS endpoint.
   *
   * @param endpoint WS endpoint
   * @param wsInvocation web service invocation
   * @throws Exception if any error occurs
   */
  public void invoke(final Endpoint endpoint, final Invocation wsInvocation) throws Exception {
    try {
      // prepare for invocation
      onBeforeInvocation(wsInvocation);
      // prepare invocation data
      final ComponentView componentView = getComponentView();
      Component component = componentView.getComponent();
      // for spring integration and @FactoryType is annotated we don't need to go into ee's
      // interceptors
      if (wsInvocation.getInvocationContext().getTargetBean() != null
              && (endpoint.getProperty("SpringBus") != null)
          || wsInvocation.getInvocationContext().getProperty("forceTargetBean") != null) {
        this.reference =
            new ManagedReference() {
              public void release() {}

              public Object getInstance() {
                return wsInvocation.getInvocationContext().getTargetBean();
              }
            };
        if (component instanceof WSComponent) {
          ((WSComponent) component).setReference(reference);
        }
      }
      final Method method =
          getComponentViewMethod(wsInvocation.getJavaMethod(), componentView.getViewMethods());
      final InterceptorContext context = new InterceptorContext();
      prepareForInvocation(context, wsInvocation);
      context.setMethod(method);
      context.setParameters(wsInvocation.getArgs());
      context.putPrivateData(Component.class, component);
      context.putPrivateData(ComponentView.class, componentView);
      if (wsInvocation.getInvocationContext().getProperty("forceTargetBean") != null) {
        context.putPrivateData(ManagedReference.class, reference);
      }
      // invoke method
      final Object retObj = componentView.invoke(context);
      // set return value
      wsInvocation.setReturnValue(retObj);
    } catch (Throwable t) {
      handleInvocationException(t);
    } finally {
      onAfterInvocation(wsInvocation);
    }
  }
  @Override
  public void customize(Object beanInstance) {
    if (beanInstance instanceof EndpointImpl) {
      configureEndpoint((EndpointImpl) beanInstance);
    }
    if (beanInstance instanceof ServerFactoryBean) {
      ServerFactoryBean factory = (ServerFactoryBean) beanInstance;

      if (factory.getInvoker() instanceof JBossWSInvoker) {
        ((JBossWSInvoker) factory.getInvoker()).setTargetBean(factory.getServiceBean());
      }
      List<Endpoint> depEndpoints = dep.getService().getEndpoints();
      if (depEndpoints != null) {
        final String targetBeanName = factory.getServiceBean().getClass().getName();
        for (Endpoint depEndpoint : depEndpoints) {
          if (depEndpoint.getTargetBeanClass().getName().equals(targetBeanName)) {
            depEndpoint.addAttachment(Object.class, factory.getServiceBean());
          }
        }
      }
    }
    if (beanInstance instanceof ServiceImpl) {
      ServiceImpl service = (ServiceImpl) beanInstance;
      List<Endpoint> depEndpoints = dep.getService().getEndpoints();
      if (depEndpoints != null) {
        final Collection<org.apache.cxf.endpoint.Endpoint> eps = service.getEndpoints().values();
        for (Endpoint depEp : depEndpoints) {
          for (org.apache.cxf.endpoint.Endpoint ep : eps) {
            if (ep.getService().getName().equals(depEp.getProperty(Message.WSDL_SERVICE))
                && ep.getEndpointInfo().getName().equals(depEp.getProperty(Message.WSDL_PORT))) {
              depEp.addAttachment(org.apache.cxf.endpoint.Endpoint.class, ep);
            }
          }
        }
      }
    }
    if (beanInstance instanceof HTTPTransportFactory) {
      HTTPTransportFactory factory = (HTTPTransportFactory) beanInstance;
      DestinationRegistry oldRegistry = factory.getRegistry();
      if (!(oldRegistry instanceof JBossWSDestinationRegistryImpl)) {
        factory.setRegistry(new JBossWSDestinationRegistryImpl());
      }
    }
    super.customize(beanInstance);
  }
 /**
  * Initializes component view name.
  *
  * @param endpoint web service endpoint
  */
 public void init(final Endpoint endpoint) {
   componentViewName = (ServiceName) endpoint.getProperty(COMPONENT_VIEW_NAME);
 }
示例#14
0
 public static void uninstall(final Endpoint endpoint, final DeploymentUnit unit) {
   final ServiceName serviceName = getServiceName(unit, endpoint.getShortName());
   WSServices.getContainerRegistry().getRequiredService(serviceName).setMode(Mode.REMOVE);
 }
示例#15
0
 private boolean hasWebservicesMD(final Endpoint endpoint) {
   final Deployment dep = endpoint.getService().getDeployment();
   return dep.getAttachment(WebservicesMetaData.class) != null;
 }
  protected void configureEndpoint(EndpointImpl endpoint) {
    // Configure wsdl file publisher
    if (wsdlPublisher != null) {
      endpoint.setWsdlPublisher(wsdlPublisher);
    }
    // Configure according to the specified jaxws endpoint configuration
    if (!endpoint.isPublished()) // before publishing, we set the jaxws conf
    {
      final Object implementor = endpoint.getImplementor();

      // setup our invoker for http endpoints if invoker is not configured in jbossws-cxf.xml DD
      boolean isHttpEndpoint =
          endpoint.getAddress() != null
              && endpoint
                  .getAddress()
                  .substring(0, 5)
                  .toLowerCase(Locale.ENGLISH)
                  .startsWith("http");
      if ((endpoint.getInvoker() == null) && isHttpEndpoint) {
        final AnnotationsInfo ai = dep.getAttachment(AnnotationsInfo.class);
        endpoint.setInvoker(
            new JBossWSInvoker(ai.hasAnnotatedClasses(UseAsyncMethod.class.getName())));
      }

      // ** Endpoint configuration setup **
      final String endpointClassName = implementor.getClass().getName();
      final List<Endpoint> depEndpoints = dep.getService().getEndpoints();
      for (Endpoint depEndpoint : depEndpoints) {
        if (endpointClassName.equals(depEndpoint.getTargetBeanName())) {
          org.jboss.wsf.spi.metadata.config.EndpointConfig config = depEndpoint.getEndpointConfig();
          if (config == null) {
            // the ASIL did not set the endpoint configuration, perhaps because we're processing an
            // Endpoint.publish() API started endpoint or because we're on WildFly 8.0.0.Final or
            // previous version. We compute the config here then (clearly no container injection
            // will be performed on optional handlers attached to the config)
            BasicConfigResolver bcr = new BasicConfigResolver(dep, implementor.getClass());
            config = bcr.resolveEndpointConfig();
            depEndpoint.setEndpointConfig(config);
          }
          if (config != null) {
            endpoint.setEndpointConfig(config);
          }

          // also save Service QName and Port QName in the endpoint for later matches
          depEndpoint.setProperty(Message.WSDL_PORT, endpoint.getEndpointName());
          depEndpoint.setProperty(Message.WSDL_SERVICE, endpoint.getServiceName());
        }
      }

      // JASPI
      final JASPIAuthenticationProvider jaspiProvider =
          (JASPIAuthenticationProvider)
              ServiceLoader.loadService(
                  JASPIAuthenticationProvider.class.getName(),
                  null,
                  ClassLoaderProvider.getDefaultProvider().getServerIntegrationClassLoader());
      if (jaspiProvider == null) {
        Loggers.DEPLOYMENT_LOGGER.cannotFindJaspiClasses();
      } else {
        if (jaspiProvider.enableServerAuthentication(endpoint, depEndpoints.get(0))) {
          endpoint.getInInterceptors().add(new AuthenticationMgrSubjectCreatingInterceptor());
        }
      }
    }
  }