Examples with EjbBundleDescriptor com.sun.enterprise.deployment.EjbBundleDescriptor used on opensource projects

Example 26 with EjbBundleDescriptor

use of com.sun.enterprise.deployment.EjbBundleDescriptor in project Payara by payara.

the class ListSubComponentsCommand method getModuleLevelComponents.

private Map<String, String> getModuleLevelComponents(BundleDescriptor bundle, String type, Map<String, String> subComponentsMap) {
    Map<String, String> moduleSubComponentMap = new LinkedHashMap<String, String>();
    if (bundle instanceof WebBundleDescriptor) {
        WebBundleDescriptor wbd = (WebBundleDescriptor) bundle;
        // look at ejb in war case
        Collection<EjbBundleDescriptor> ejbBundleDescs = wbd.getExtensionsDescriptors(EjbBundleDescriptor.class);
        if (ejbBundleDescs.size() > 0) {
            EjbBundleDescriptor ejbBundle = ejbBundleDescs.iterator().next();
            moduleSubComponentMap.putAll(getModuleLevelComponents(ejbBundle, type, subComponentsMap));
        }
        if (type != null && type.equals("ejbs")) {
            return moduleSubComponentMap;
        }
        for (WebComponentDescriptor wcd : wbd.getWebComponentDescriptors()) {
            StringBuffer sb = new StringBuffer();
            String canonicalName = wcd.getCanonicalName();
            sb.append("<");
            // The component type is limited to JSP or Servlet at this level. JAX-RS resources for example need to be obtained elsewhere.
            String wcdType = (wcd.isServlet() ? "Servlet" : "JSP");
            sb.append(wcdType);
            sb.append(">");
            moduleSubComponentMap.put(canonicalName, sb.toString());
            subComponentsMap.put(wcd.getCanonicalName(), wcdType);
        }
    } else if (bundle instanceof EjbBundleDescriptor) {
        if (type != null && type.equals("servlets")) {
            return moduleSubComponentMap;
        }
        EjbBundleDescriptor ebd = (EjbBundleDescriptor) bundle;
        for (EjbDescriptor ejbDesc : ebd.getEjbs()) {
            StringBuffer sb = new StringBuffer();
            String ejbName = ejbDesc.getName();
            sb.append("<");
            String ejbType = ejbDesc.getEjbTypeForDisplay();
            sb.append(ejbType);
            sb.append(">");
            moduleSubComponentMap.put(ejbName, sb.toString());
            subComponentsMap.put(ejbDesc.getName(), ejbType);
        }
    }
    return moduleSubComponentMap;
}

Example 27 with EjbBundleDescriptor

use of com.sun.enterprise.deployment.EjbBundleDescriptor in project Payara by payara.

the class HandlerChainHandler method processHandlerChainAnnotation.

public HandlerProcessingResult processHandlerChainAnnotation(AnnotationInfo annInfo, AnnotatedElementHandler annCtx, AnnotatedElement annElem, Class declaringClass, boolean serviceSideChain) throws AnnotationProcessorException {
    HandlerChain hChain = null;
    boolean clientSideHandlerChain = false;
    if (serviceSideChain) {
        // Ignore @WebService annotation on an interface; process only those in an actual service impl class
        if (declaringClass.isInterface()) {
            return HandlerProcessingResultImpl.getDefaultResult(getAnnotationType(), ResultType.PROCESSED);
        }
        // The @HandlerChain can be in the impl class (typically in the java-wsdl case) or
        // can be in the SEI also. Check if there is handler chain in the impl class.
        // If so, the @HandlerChain in impl class gets precedence
        hChain = annElem.getAnnotation(HandlerChain.class);
        if (hChain == null) {
            WebService webService = (WebService) declaringClass.getAnnotation(WebService.class);
            if (webService != null) {
                if (webService.endpointInterface() != null && webService.endpointInterface().length() > 0) {
                    Class endpointIntf;
                    try {
                        endpointIntf = declaringClass.getClassLoader().loadClass(webService.endpointInterface());
                    } catch (java.lang.ClassNotFoundException cfne) {
                        throw new AnnotationProcessorException(localStrings.getLocalString("enterprise.deployment.annotation.handlers.classnotfound", "class {0} referenced from annotation symbol cannot be loaded", new Object[] { webService.endpointInterface() }), annInfo);
                    }
                    if (endpointIntf.getAnnotation(HandlerChain.class) != null) {
                        hChain = (HandlerChain) endpointIntf.getAnnotation(HandlerChain.class);
                    }
                }
            }
        }
    } else {
        // this is a client side handler chain
        hChain = annElem.getAnnotation(HandlerChain.class);
        clientSideHandlerChain = true;
    }
    // At this point the hChain should be the annotation to use.
    if (hChain == null) {
        return HandlerProcessingResultImpl.getDefaultResult(getAnnotationType(), ResultType.PROCESSED);
    }
    // At this point the hChain should be the annotation to use.
    String handlerFile = hChain.file();
    HandlerChainContainer[] containers = null;
    if (annCtx instanceof HandlerContext) {
        containers = ((HandlerContext) annCtx).getHandlerChainContainers(serviceSideChain, declaringClass);
    }
    if (!clientSideHandlerChain && (containers == null || containers.length == 0)) {
        for (Annotation ann : annElem.getAnnotations()) {
            if (ann.annotationType().getPackage().getName().startsWith("javax.ejb")) {
                // let EJB handlers handle this processing
                return HandlerProcessingResultImpl.getDefaultResult(getAnnotationType(), ResultType.UNPROCESSED);
            }
        }
        // could not find my web service...
        throw new AnnotationProcessorException(localStrings.getLocalString("enterprise.deployment.annotation.handlers.componentnotfound", "component referenced from annotation symbol cannot be found"), annInfo);
    }
    try {
        URL handlerFileURL = null;
        try {
            handlerFileURL = new URL(handlerFile);
        } catch (java.net.MalformedURLException e) {
        // swallowing purposely
        }
        InputStream handlerFileStream;
        if (handlerFileURL == null) {
            ClassLoader clo = annInfo.getProcessingContext().getProcessingInput().getClassLoader();
            handlerFileStream = clo.getResourceAsStream(handlerFile);
            if (handlerFileStream == null) {
                String y = declaringClass.getPackage().getName().replaceAll("\\.", "/");
                handlerFileStream = clo.getResourceAsStream(declaringClass.getPackage().getName().replaceAll("\\.", "/") + "/" + handlerFile);
            }
            if (handlerFileStream == null) {
                // So check in the generated SEI's package
                if (annElem instanceof Class) {
                    String y = ((Class) annElem).getPackage().getName().replaceAll("\\.", "/");
                    handlerFileStream = clo.getResourceAsStream(((Class) annElem).getPackage().getName().replaceAll("\\.", "/") + "/" + handlerFile);
                }
            }
        } else {
            handlerFileStream = handlerFileURL.openConnection().getInputStream();
        }
        if (handlerFileStream == null) {
            throw new AnnotationProcessorException(localStrings.getLocalString("enterprise.deployment.annotation.handlers.handlerfilenotfound", "handler file {0} not found", new Object[] { handlerFile }), annInfo);
        }
        Document document;
        try {
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            factory.setNamespaceAware(true);
            factory.setExpandEntityReferences(false);
            factory.setFeature("http://apache.org/xml/features/disallow-doctype-decl", true);
            DocumentBuilder builder = factory.newDocumentBuilder();
            document = builder.parse(handlerFileStream);
        } catch (SAXParseException spe) {
            throw new AnnotationProcessorException(localStrings.getLocalString("enterprise.deployment.annotation.handlers.parserexception", "{0} XML Parsing error : line  {1} ; Error = {2}", new Object[] { handlerFile, spe.getLineNumber(), spe.getMessage() }));
        } finally {
            if (handlerFileStream != null) {
                handlerFileStream.close();
            }
        }
        for (HandlerChainContainer container : containers) {
            boolean fromDD = true;
            if (!container.hasHandlerChain()) {
                fromDD = false;
                processHandlerFile(document, container);
            }
            // we now need to create the right context to push on the stack
            // and manually invoke the handlers annotation processing since
            // we know they are Jax-ws handlers.
            List<WebServiceHandlerChain> chains = container.getHandlerChain();
            ArrayList<Class> handlerClasses = new ArrayList<Class>();
            ClassLoader clo = annInfo.getProcessingContext().getProcessingInput().getClassLoader();
            for (WebServiceHandlerChain chain : chains) {
                for (WebServiceHandler handler : chain.getHandlers()) {
                    String className = handler.getHandlerClass();
                    try {
                        handlerClasses.add(clo.loadClass(className));
                    } catch (ClassNotFoundException e) {
                        if (fromDD) {
                            conLogger.log(Level.WARNING, LogUtils.DDHANDLER_NOT_FOUND, className);
                        } else {
                            conLogger.log(Level.WARNING, LogUtils.HANDLER_FILE_HANDLER_NOT_FOUND, new Object[] { className, handlerFile });
                        }
                    }
                }
            }
            // we have the list of handler classes, we can now
            // push the context and call back annotation processing.
            Descriptor jndiContainer = null;
            if (serviceSideChain) {
                WebServiceEndpoint endpoint = (WebServiceEndpoint) container;
                if (DOLUtils.warType().equals(endpoint.getBundleDescriptor().getModuleType())) {
                    jndiContainer = endpoint.getBundleDescriptor();
                } else {
                    jndiContainer = Descriptor.class.cast(endpoint.getEjbComponentImpl());
                }
            } else {
                ServiceReferenceDescriptor ref = (ServiceReferenceDescriptor) container;
                if (DOLUtils.ejbType().equals(ref.getBundleDescriptor().getModuleType())) {
                    EjbBundleDescriptor ejbBundle = (EjbBundleDescriptor) ref.getBundleDescriptor();
                    Iterator<? extends EjbDescriptor> ejbsIter = ejbBundle.getEjbs().iterator();
                    while (ejbsIter.hasNext()) {
                        EjbDescriptor ejb = ejbsIter.next();
                        try {
                            if (ejb.getServiceReferenceByName(ref.getName()) != null) {
                                // found the ejb; break out of the loop
                                jndiContainer = Descriptor.class.cast(ejb);
                                break;
                            }
                        } catch (IllegalArgumentException illex) {
                        // this ejb does not have a service-ref by this name;
                        // swallow this exception and  go to next
                        }
                    }
                } else {
                    jndiContainer = ref.getBundleDescriptor();
                }
            }
            ResourceContainerContextImpl newContext = new ResourceContainerContextImpl(jndiContainer);
            ProcessingContext ctx = annInfo.getProcessingContext();
            ctx.pushHandler(newContext);
            // process the classes
            annInfo.getProcessingContext().getProcessor().process(annInfo.getProcessingContext(), handlerClasses.toArray(new Class[handlerClasses.size()]));
            ctx.popHandler();
        }
    } catch (Throwable t) {
        throw new AnnotationProcessorException(t.getMessage(), annInfo);
    }
    return HandlerProcessingResultImpl.getDefaultResult(getAnnotationType(), ResultType.PROCESSED);
}

Example 28 with EjbBundleDescriptor

use of com.sun.enterprise.deployment.EjbBundleDescriptor in project Payara by payara.

the class WebServiceProviderHandler method processAnnotation.

@Override
public HandlerProcessingResult processAnnotation(AnnotationInfo annInfo) throws AnnotationProcessorException {
    AnnotatedElementHandler annCtx = annInfo.getProcessingContext().getHandler();
    AnnotatedElement annElem = annInfo.getAnnotatedElement();
    boolean ejbInWar = ignoreWebserviceAnnotations(annElem, annCtx);
    // and add webservices to that BundleDescriptor
    if (ejbInWar) {
        return HandlerProcessingResultImpl.getDefaultResult(getAnnotationType(), ResultType.PROCESSED);
    }
    // sanity check
    if (!(annElem instanceof Class)) {
        AnnotationProcessorException ape = new AnnotationProcessorException("@WebServiceProvider can only be specified on TYPE", annInfo);
        annInfo.getProcessingContext().getErrorHandler().error(ape);
        return HandlerProcessingResultImpl.getDefaultResult(getAnnotationType(), ResultType.FAILED);
    }
    if (isJaxwsRIDeployment(annInfo)) {
        // Looks like JAX-WS RI specific deployment, do not process Web Service annotations otherwise would end up as two web service endpoints
        conLogger.log(Level.INFO, LogUtils.DEPLOYMENT_DISABLED, new Object[] { annInfo.getProcessingContext().getArchive().getName(), "WEB-INF/sun-jaxws.xml" });
        return HandlerProcessingResultImpl.getDefaultResult(getAnnotationType(), ResultType.PROCESSED);
    }
    // WebServiceProvider MUST implement the provider interface, let's check this
    if (!javax.xml.ws.Provider.class.isAssignableFrom((Class) annElem)) {
        AnnotationProcessorException ape = new AnnotationProcessorException(annElem.toString() + "does not implement the javax.xml.ws.Provider interface", annInfo);
        annInfo.getProcessingContext().getErrorHandler().error(ape);
        return HandlerProcessingResultImpl.getDefaultResult(getAnnotationType(), ResultType.FAILED);
    }
    // let's get the main annotation of interest.
    javax.xml.ws.WebServiceProvider ann = (javax.xml.ws.WebServiceProvider) annInfo.getAnnotation();
    BundleDescriptor bundleDesc = null;
    try {
        // let's see the type of web service we are dealing with...
        if (ejbProvider != null && ejbProvider.getType("javax.ejb.Stateless") != null) {
            // this is an ejb !
            if (annCtx instanceof EjbContext) {
                EjbContext ctx = (EjbContext) annCtx;
                bundleDesc = ctx.getDescriptor().getEjbBundleDescriptor();
                bundleDesc.setSpecVersion("3.0");
            } else if (annCtx instanceof EjbsContext) {
                String name = getEjbName(annElem);
                for (EjbContext ejbCtx : ((EjbsContext) annCtx).getEjbContexts()) {
                    EjbDescriptor descriptor = ejbCtx.getDescriptor();
                    if (name.equals(descriptor.getName())) {
                        bundleDesc = descriptor.getEjbBundleDescriptor();
                        bundleDesc.setSpecVersion("3.0");
                        break;
                    }
                }
            }
        }
        if (bundleDesc == null) {
            // this has to be a servlet
            if (annCtx instanceof WebComponentContext) {
                bundleDesc = ((WebComponentContext) annCtx).getDescriptor().getWebBundleDescriptor();
            } else if (!(annCtx instanceof WebBundleContext)) {
                return getInvalidAnnotatedElementHandlerResult(annInfo.getProcessingContext().getHandler(), annInfo);
            }
            bundleDesc = ((WebBundleContext) annCtx).getDescriptor();
            bundleDesc.setSpecVersion("2.5");
        }
    } catch (Exception e) {
        throw new AnnotationProcessorException(wsLocalStrings.getLocalString("webservice.annotation.exception", "WS00023: Exception in processing @Webservice : {0}", e.getMessage()));
    }
    // For WSProvider, portComponentName is the fully qualified class name
    String portComponentName = ((Class) annElem).getName();
    // As per JSR181, the serviceName is either specified in the deployment descriptor
    // or in @WebSErvice annotation in impl class; if neither service name implclass+Service
    String svcName = ann.serviceName();
    if (svcName == null) {
        svcName = "";
    }
    // Store binding type specified in Impl class
    String userSpecifiedBinding = null;
    javax.xml.ws.BindingType bindingAnn = (javax.xml.ws.BindingType) ((Class) annElem).getAnnotation(javax.xml.ws.BindingType.class);
    if (bindingAnn != null) {
        userSpecifiedBinding = bindingAnn.value();
    }
    // In case user gives targetNameSpace in the Impl class, that has to be used as
    // the namespace for service, port; typically user will do this in cases where
    // port_types reside in a different namespace than that of server/port.
    // Store the targetNameSpace, if any, in the impl class for later use
    String targetNameSpace = ann.targetNamespace();
    if (targetNameSpace == null) {
        targetNameSpace = "";
    }
    String portName = ann.portName();
    if (portName == null) {
        portName = "";
    }
    // Check if the same endpoint is already defined in webservices.xml
    WebServicesDescriptor wsDesc = bundleDesc.getWebServices();
    WebServiceEndpoint endpoint = wsDesc.getEndpointByName(portComponentName);
    WebService newWS;
    if (endpoint == null) {
        // If so, add this endpoint to the existing service
        if (svcName.length() != 0) {
            newWS = wsDesc.getWebServiceByName(svcName);
        } else {
            newWS = wsDesc.getWebServiceByName(((Class) annElem).getSimpleName());
        }
        if (newWS == null) {
            newWS = new WebService();
            // service name from annotation
            if (svcName.length() != 0) {
                newWS.setName(svcName);
            } else {
                newWS.setName(((Class) annElem).getSimpleName());
            }
            wsDesc.addWebService(newWS);
        }
        endpoint = new WebServiceEndpoint();
        // port-component-name is fully qualified class name
        endpoint.setEndpointName(portComponentName);
        newWS.addEndpoint(endpoint);
        wsDesc.setSpecVersion(WebServicesDescriptorNode.SPEC_VERSION);
    } else {
        newWS = endpoint.getWebService();
    }
    // present overrides everything else
    if (endpoint.getWsdlService() != null) {
        if ((targetNameSpace.length() > 0) && (!endpoint.getWsdlService().getNamespaceURI().equals(targetNameSpace))) {
            throw new AnnotationProcessorException("Target Namespace inwsdl-service element does not match @WebService.targetNamespace", annInfo);
        }
        targetNameSpace = endpoint.getWsdlService().getNamespaceURI();
    }
    // Set binding id id @BindingType is specified by the user in the impl class
    if ((!endpoint.hasUserSpecifiedProtocolBinding()) && (userSpecifiedBinding != null) && (userSpecifiedBinding.length() != 0)) {
        endpoint.setProtocolBinding(userSpecifiedBinding);
    }
    // Use annotated values only if the deployment descriptor equivalent has not been specified
    if (newWS.getWsdlFileUri() == null) {
        // take wsdl location from annotation
        if (ann.wsdlLocation() != null && ann.wsdlLocation().length() != 0) {
            newWS.setWsdlFileUri(ann.wsdlLocation());
        }
    }
    annElem = annInfo.getAnnotatedElement();
    // we checked that the endpoint implements the provider interface above
    Class clz = (Class) annElem;
    Class serviceEndpointIntf = null;
    for (Class intf : clz.getInterfaces()) {
        if (javax.xml.ws.Provider.class.isAssignableFrom(intf)) {
            serviceEndpointIntf = intf;
            break;
        }
    }
    if (serviceEndpointIntf == null) {
        endpoint.setServiceEndpointInterface("javax.xml.ws.Provider");
    } else {
        endpoint.setServiceEndpointInterface(serviceEndpointIntf.getName());
    }
    if (DOLUtils.warType().equals(bundleDesc.getModuleType())) {
        if (endpoint.getServletImplClass() == null) {
            // Set servlet impl class here
            endpoint.setServletImplClass(((Class) annElem).getName());
        }
        // Servlet link name
        WebBundleDescriptor webBundle = (WebBundleDescriptor) bundleDesc;
        if (endpoint.getWebComponentLink() == null) {
            endpoint.setWebComponentLink(portComponentName);
        }
        if (endpoint.getWebComponentImpl() == null) {
            WebComponentDescriptor webComponent = (WebComponentDescriptor) webBundle.getWebComponentByCanonicalName(endpoint.getWebComponentLink());
            if (webComponent == null) {
                // GLASSFISH-3297
                WebComponentDescriptor[] wcs = webBundle.getWebComponentByImplName(((Class) annElem).getCanonicalName());
                if (wcs.length > 0) {
                    webComponent = wcs[0];
                }
            }
            // if servlet is not known, we should add it now
            if (webComponent == null) {
                webComponent = new WebComponentDescriptorImpl();
                webComponent.setServlet(true);
                webComponent.setWebComponentImplementation(((Class) annElem).getCanonicalName());
                webComponent.setName(endpoint.getEndpointName());
                webComponent.addUrlPattern("/" + newWS.getName());
                webBundle.addWebComponentDescriptor(webComponent);
            }
            endpoint.setWebComponentImpl(webComponent);
        }
    } else {
        String name = getEjbName(annElem);
        EjbDescriptor ejb = ((EjbBundleDescriptor) bundleDesc).getEjbByName(name);
        endpoint.setEjbComponentImpl(ejb);
        ejb.setWebServiceEndpointInterfaceName(endpoint.getServiceEndpointInterface());
        if (endpoint.getEjbLink() == null) {
            endpoint.setEjbLink(ejb.getName());
        }
    }
    if (endpoint.getWsdlPort() == null) {
        endpoint.setWsdlPort(new QName(targetNameSpace, portName, "ns1"));
    }
    if (endpoint.getWsdlService() == null) {
        endpoint.setWsdlService(new QName(targetNameSpace, svcName, "ns1"));
    }
    return HandlerProcessingResultImpl.getDefaultResult(getAnnotationType(), ResultType.PROCESSED);
}