Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
   *
   * Copyright (c) 1997-2013 Oracle and/or its affiliates. All rights reserved.
   *
   * The contents of this file are subject to the terms of either the GNU
   * General Public License Version 2 only ("GPL") or the Common Development
   * and Distribution License("CDDL") (collectively, the "License").  You
   * may not use this file except in compliance with the License.  You can
  * obtain a copy of the License at
  * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
  * or packager/legal/LICENSE.txt.  See the License for the specific
  * language governing permissions and limitations under the License.
  *
  * When distributing the software, include this License Header Notice in each
  * file and include the License file at packager/legal/LICENSE.txt.
  *
  * GPL Classpath Exception:
  * Oracle designates this particular file as subject to the "Classpath"
  * exception as provided by Oracle in the GPL Version 2 section of the License
  * file that accompanied this code.
  *
  * Modifications:
  * If applicable, add the following below the License Header, with the fields
  * enclosed by brackets [] replaced by your own identifying information:
  * "Portions Copyright [year] [name of copyright owner]"
  *
  * Contributor(s):
  * If you wish your version of this file to be governed by only the CDDL or
  * only the GPL Version 2, indicate your decision by adding "[Contributor]
  * elects to include this software in this distribution under the [CDDL or GPL
  * Version 2] license."  If you don't indicate a single choice of license, a
  * recipient has the option to distribute your version of this file under
  * either the CDDL, the GPL Version 2 or to extend the choice of license to
  * its licensees as provided above.  However, if you add GPL Version 2 code
  * and therefore, elected the GPL Version 2 license, then the option applies
  * only if the new code is made subject to such option by the copyright
  * holder.
  */
 
 package org.glassfish.webservices.codegen;
 
 import java.util.List;
 import java.io.File;
 import java.net.URL;
 import java.net.URI;
 
 
 
 // DOL imports
 import  org.glassfish.hk2.api.ServiceLocator;
 
 
 // TODO : Neds quivalent
 //import com.sun.enterprise.deployment.backend.Deployer;
 
 
 // web service impl imports
 
 
 //JAX-RPC SPI
This class is responsible for generating all non portable jax-rpc artifacts for a single .ear or standalone module.

Author(s):
Jerome Dochez
public class JaxRpcRICodegen extends ModuleContentLinker
    protected DeploymentContext context = null;
    protected ServiceLocator habitat = null;
    protected String moduleClassPath = null;
    // list of generated files
    ArrayList<Stringfiles = new ArrayList<String>();
    private static final Logger logger = WsUtil.getDefaultLogger();
    // total number of times wscompile is invoked for the .ear or the
    // standalone module.
    private int wscompileInvocationCount = 0;
    // resources...
    private static LocalStringManagerImpl localStrings =
            new LocalStringManagerImpl(JaxRpcRICodegen.class);
    private CompileTool wscompileForAccept = null;
    private CompileTool wscompileForWebServices = null;
    //is this invocation for processing service references or services?
    private boolean processServiceReferences = false;
    private boolean hasWebServiceClients = false;

    
Creates a new instance of JaxRpcRICodegen
    public JaxRpcRICodegen(boolean processServiceReferences) {
         = JaxRpcObjectFactory.newInstance();
        this. = processServiceReferences;
    }
    @Override
    public void run(ServiceLocator habitatDeploymentContext contextString cpthrows Exception {
         = new FileArchive();
        BundleDescriptor bundle = DOLUtils.getCurrentBundleForContext(context);
        if (bundle.hasWebServiceClients() && (bundle instanceof ApplicationClientDescriptor)) {
             = true;
        }
        if(bundle.isStandalone()) {
            .open(context.getSourceDir().toURI());
        } else {
            .open(context.getSource().getParentArchive().getURI());
        }
        this. = context;
        this. = habitat;
        this. = cp;
        Application application = context.getModuleMetaData(Application.class);
        application.visit((ApplicationVisitorthis);
    }

    
Visits a webs service reference
    @Override
    public void accept(ServiceReferenceDescriptor serviceRef)  {
        if(!) {
           return;
        }
        boolean codegenRequired = false;
        URL wsdlOverride = null;
        boolean wsdlOverriden = false;
        boolean jaxwsClient = false;
        super.accept(serviceRef);
        try {
            ClassLoader clr = serviceRef.getBundleDescriptor().getClassLoader();
            if ( serviceRef.getServiceInterface() != null ) {
                Class serviceInterface = clr.loadClass(serviceRef.getServiceInterface());
                if (javax.xml.ws.Service.class.isAssignableFrom(serviceInterface)) {
                    jaxwsClient = true;
                }
            }
            // Resolve port component links to target endpoint address.
            // We can't assume web service client is running in same VM
            // as endpoint in the intra-app case because of app clients.
            //
            // Also set port-qname based on linked port's qname if not
            // already set.
            for(Iterator ports = serviceRef.getPortsInfo().iterator(); ports.hasNext();) {
                ServiceRefPortInfo portInfo = (ServiceRefPortInfoports.next();
                ifportInfo.isLinkedToPortComponent() ) {
                    WebServiceEndpoint linkedPortComponent = portInfo.getPortComponentLink();
                    if (linkedPortComponent==null) {
                        throw new Exception(.getLocalString(
                                "enterprise.webservice.componentlinkunresolved",
                                "The port-component-link {0} cannot be resolved",
                                new Object[] {portInfo.getPortComponentLinkName()}));
                    }
                    WsUtil wsUtil = new WsUtil();
                    WebServerInfo wsi = wsUtil.getWebServerInfoForDAS();
                    URL rootURL = wsi.getWebServerRootURL(linkedPortComponent.isSecure());
                    URL actualAddress = linkedPortComponent.composeEndpointAddress(rootURL);
                    if(jaxwsClient) {
                        portInfo.addStubProperty(....,
                                actualAddress.toExternalForm());
                    } else {
                        portInfo.addStubProperty(.actualAddress.toExternalForm());
                    }
                    if (serviceRef.getBundleDescriptor().getModuleType().equals(DOLUtils.carType())) {
                        wsdlOverride = serviceRef.getWsdlOverride();
                        if (wsdlOverride!=null) {
                            wsdlOverriden = true;
                            serviceRef.setWsdlOverride(linkedPortComponent.getWebService().getWsdlFileUrl());
                        }
                    }
                }
            }
            // If this is a post JAXRPC-1.1 based web service, then no need for code gen etc etc
            if(jaxwsClient) {
                return;
            }
            ifserviceRef.hasGeneratedServiceInterface() ) {
                ifserviceRef.hasWsdlFile() && serviceRef.hasMappingFile() ) {
                    codegenRequired = true;
                } else {
                    throw new Exception
                            ("Deployment error for service-ref " + serviceRef.getName()
                                    + ".\nService references with generated service " +
                                    "interface must include WSDL and mapping information.");
                }
            } else {
                ifserviceRef.hasWsdlFile() ) {
                    ifserviceRef.hasMappingFile() ) {
                        codegenRequired = true;
                    } else {
                        throw new Exception
                                ("Deployment error for service-ref " + serviceRef.getName()
                                        + ".\nService references with wsdl must also have " +
                                        "mapping information.");
                    }
                }
            }
            ifcodegenRequired ) {
                ModelInfo modelInfo = createModelInfo(serviceRef);
                /*
                 * If clients exist, force regeneration so that the
                 * ClientArtifactsManager is populated. Issue 10612.
                 */
                String args[] = createJaxrpcCompileArgs(
                    false);
                CompileTool wscompile =
                        .createCompileTool(."wscompile");
                 = wscompile;
                WsCompile delegate =
                        new WsCompile(wscompileserviceRef);
                delegate.setModelInfo(modelInfo);
                wscompile.setDelegate(delegate);
                jaxrpc(argsdelegateserviceRef);
                if ()   {
                    addArtifactsForAppClient();
                }
            }
            if (wsdlOverriden) {
                serviceRef.setWsdlOverride(wsdlOverride);
            }
        } catch(IllegalStateException e) {
            //do nothing
           .info("Attempting to add artifacts for appClient after artifacts were generated" +
                   " "+e.getMessage());
        }  catch(Exception e) {
            RuntimeException re = new RuntimeException(e.getMessage());
            re.initCause(e);
            throw re;
        }
    }
    private void addArtifactsForAppClient(){
        ClientArtifactsManager cArtifactsManager = ClientArtifactsManager.get();
        for (int i = 0; i < .size(); i ++) {
            URI baseURI = .getScratchDir("ejb").toURI();
            File file = new File(.get(i));
            URI artifact = baseURI.relativize(file.toURI());
            //Fix for issue 9734
            if (!cArtifactsManager.contains(baseURI,artifact) ){
               cArtifactsManager.add(baseURIartifact);
            }
        }
    }

    
visits a web service definition

Parameters:
webService
    @Override
    public void accept(WebService webService) {
        if() {
           return;
        }
        if (!webServiceInContext(webService)) {
            return;
        }
        super.accept(webService);
        try {
            if((new WsUtil()).isJAXWSbasedService(webService)) {
                WsUtil wsUtil = new WsUtil();
                Collection<WebServiceEndpointendpoints = webService.getEndpoints();
                for(WebServiceEndpoint ep : endpoints) {
                    ifep.implementedByWebComponent() ) {
                        wsUtil.updateServletEndpointRuntime(ep);
                    } else {
                        wsUtil.validateEjbEndpoint(ep);
                    }
                }
                //wsImport(webService,  files);
            } else {
                jaxrpcWebService(webService);
            }
        } catch(Exception e) {
            RuntimeException ge =new RuntimeException(e.getMessage());
            ge.initCause(e);
            throw ge;
        }
    }
    @Override
    public Iterator getListOfBinaryFiles() {
        return .iterator();
    }
    @Override
    public Iterator getListOfSourceFiles() {
        // for now I do not maintain those
        return null;
    }

    
Releases resources used during the code gen and compilation.
    @Override
    public void done() {
//        done(CompileTool) is now invoked after each compilation is complete
//        from inside the jaxrpc method.  Otherwise, multiple uses of jaxrpc could
//        cause continued file locking on Windows since only the last one was 
//        recorded in the wscompileForxxx variables.
//        
//        done(wscompileForAccept);
//        done(wscompileForWebServices);
    }

    
Navigates to the URLClassLoader used by the jaxrpc compilation and releases it.

Parameters:
wscompile the CompileTool whose loader is to be released
    private void done(CompileTool wscompile) {
        /*
         *Follow the object graph to the loader: 
         *basically CompileTool -> ProcessorEnvironment -> the URLClassLoader.
         */
        if (wscompile != null && wscompile instanceof com.sun.xml.rpc.tools.wscompile.CompileTool) {
            com.sun.xml.rpc.tools.wscompile.CompileTool compileTool = (com.sun.xml.rpc.tools.wscompile.CompileToolwscompile;
            com.sun.xml.rpc.spi.tools.ProcessorEnvironment env = compileTool.getEnvironment();
            if (env != null && env instanceof com.sun.xml.rpc.processor.util.ProcessorEnvironment) {
                com.sun.xml.rpc.processor.util.ProcessorEnvironment typedEnv = (com.sun.xml.rpc.processor.util.ProcessorEnvironmentenv;
                java.net.URLClassLoader urlCL = typedEnv.getClassLoader();
                ClassLoaderUtil.releaseLoader(urlCL);
            }
        }
    }
    private JaxrpcMappingDescriptor getJaxrpcMappingInfo(URL mappingFileUrl,
                                                         Descriptor desc)
            throws Exception {
        JaxrpcMappingDescriptor mappingDesc = null;
        InputStream is = null;
        try {
            is = mappingFileUrl.openStream();
            JaxrpcMappingDeploymentDescriptorFile jaxrpcDD =
                    new JaxrpcMappingDeploymentDescriptorFile();
            // useful for validation errors...
            if (desc instanceof ServiceReferenceDescriptor) {
                ServiceReferenceDescriptor srd = (ServiceReferenceDescriptordesc;
                jaxrpcDD.setDeploymentDescriptorPath(srd.getMappingFileUri());
                jaxrpcDD.setErrorReportingString(srd.getBundleDescriptor().getModuleDescriptor().getArchiveUri());
            }
            if (desc instanceof WebService) {
                WebService ws = (WebServicedesc;
                jaxrpcDD.setDeploymentDescriptorPath(ws.getMappingFileUri());
                jaxrpcDD.setErrorReportingString(ws.getBundleDescriptor().getModuleDescriptor().getArchiveUri());
            }
            //jaxrpcDD.setXMLValidationLevel(Deployer.getValidationLevel());
            jaxrpcDD.setXMLValidationLevel("none");
            mappingDesc =  jaxrpcDD.read(is);
        } finally {
            ifis != null ) {
                is.close();
            }
        }
        return mappingDesc;
    }
    private boolean isJaxrpcRIModelFile(URL mappingFileUrl) {
        boolean isModel = false;
        InputStream is  = null;
        try {
            is = mappingFileUrl.openStream();
            isModel = .createXMLModelFileFilter().isModelFile(is);
        } catch(Throwable t) {
        } finally {
            ifis != null ) {
                try {
                    is.close();
                } catch(Exception e) {}
            }
        }
        return isModel;
    }
    private ModelInfo createModelInfo(WebService webService)
            throws Exception {
        ModelInfo modelInfo = null;
        URL mappingFileUrl = webService.getMappingFile().toURL();
        modelInfo = createModelFileModelInfo(mappingFileUrl);
        ifisJaxrpcRIModelFile(mappingFileUrl) ) {
            debug("000. JaxrpcRIModelFile.");
            modelInfo = createModelFileModelInfo(mappingFileUrl);
        } else {
            JaxrpcMappingDescriptor mappingDesc =
                    getJaxrpcMappingInfo(mappingFileUrlwebService);
            ifmappingDesc.isSimpleMapping() ) {
                debug("111. SimpleMapping.");
                modelInfo = createNoMetadataModelInfo(webServicemappingDesc);
            } else {
                debug("222. FullMapping .");
                modelInfo = createFullMappingModelInfo(webService);
            }
        }
        return modelInfo;
    }
            throws Exception {
        ModelInfo modelInfo = null;
        URL mappingFileUrl = serviceRef.getMappingFile().toURL();
        ifisJaxrpcRIModelFile(mappingFileUrl) ) {
            modelInfo = createModelFileModelInfo(mappingFileUrl);
        } else {
            JaxrpcMappingDescriptor mappingDesc =
                    getJaxrpcMappingInfo(mappingFileUrlserviceRef);
            ifmappingDesc.isSimpleMapping() &&
                    serviceRef.hasGeneratedServiceInterface() ) {
                // model info for this modeler requires generated service 
                // interface name.
                modelInfo = createNoMetadataModelInfo(serviceRefmappingDesc);
            } else {
                modelInfo = createFullMappingModelInfo(serviceRef);
            }
        }
        return modelInfo;
    }
    private ModelFileModelInfo createModelFileModelInfo(URL modelFileUrl)
            throws Exception {
        modelInfo.setLocation(modelFileUrl.toExternalForm());
        return modelInfo;
    }
            throws Exception {
        URL mappingFileUrl = webService.getMappingFile().toURL();
        URL wsdlFileUrl = webService.getWsdlFileUrl();
        return createFullMappingModelInfo(mappingFileUrlwsdlFileUrl);
    }
            (ServiceReferenceDescriptor serviceRefthrows Exception {
        URL mappingFileUrl = serviceRef.getMappingFile().toURL();
        URL wsdlFileUrl = serviceRef.hasWsdlOverride() ?
                serviceRef.getWsdlOverride() : serviceRef.getWsdlFileUrl();
        return createFullMappingModelInfo(mappingFileUrlwsdlFileUrl);
    }
            (URL mappingFileURL wsdlFilethrows Exception {
        J2EEModelInfo modelInfo = .createJ2EEModelInfo(mappingFile);
        modelInfo.setLocation(wsdlFile.toExternalForm());
        // java package name not used
        modelInfo.setJavaPackageName("package_ignored");
        return modelInfo;
    }
            (WebService webServiceJaxrpcMappingDescriptor mappingDesc)
            throws Exception {
        URL wsdlFileUrl = webService.getWsdlFileUrl();
        Collection endpoints = webService.getEndpoints();
        ifendpoints.size() != 1 ) {
            throw new Exception
                    ("Deployment code generation error for webservice " +
                            webService.getName() + ". " +
                            " jaxrpc-mapping-file is required if web service has " +
                            "multiple endpoints");
        }
        WebServiceEndpoint endpoint = (WebServiceEndpoint)
                endpoints.iterator().next();
        modelInfo.setLocation(wsdlFileUrl.toExternalForm());
        modelInfo.setInterfaceName(endpoint.getServiceEndpointInterface());
        modelInfo.setPortName(endpoint.getWsdlPort());
        addNamespaceMappingRegistry(modelInfomappingDesc);
        return modelInfo;
    }
    private void addNamespaceMappingRegistry
            (NoMetadataModelInfo modelInfoJaxrpcMappingDescriptor mappingDesc) {
        NamespaceMappingRegistryInfo namespaceRegistry =
                .createNamespaceMappingRegistryInfo();
        modelInfo.setNamespaceMappingRegistry(namespaceRegistry);
        Collection mappings = mappingDesc.getMappings();
        for(Iterator iter = mappings.iterator(); iter.hasNext();) {
            Mapping next = (Mappingiter.next();
            NamespaceMappingInfo namespaceInfo =
                    .createNamespaceMappingInfo(next.getNamespaceUri(),
                            next.getPackage());
            namespaceRegistry.addMapping(namespaceInfo);
        }
    }
            (ServiceReferenceDescriptor serviceRef,
             JaxrpcMappingDescriptor mappingDescthrows Exception {
        URL wsdlFile = serviceRef.hasWsdlOverride() ?
                serviceRef.getWsdlOverride() : serviceRef.getWsdlFileUrl();
        modelInfo.setLocation(wsdlFile.toExternalForm());
        // Service endpoint interface is required.  Parse generated
        // service interface for it since we can't count on SEI
        // having been listed in standard deployment information.
        WsUtil wsUtil = new WsUtil();
        String serviceInterfaceName = serviceRef.getServiceInterface();
        if (cl instanceof ASURLClassLoader) {
            String modClassPath = ASClassLoaderUtil.getModuleClassPath();
            List<URLmoduleList = ASClassLoaderUtil.getURLsFromClasspath(modClassPath.null);
            for (Iterator<URLitr=moduleList.iterator();itr.hasNext();) {
                ((ASURLClassLoadercl).appendURL(itr.next());
            }
        }
        Class serviceInterface = cl.loadClass(serviceInterfaceName);
        Collection seis = wsUtil.getSEIsFromGeneratedService(serviceInterface);
        ifseis.size() == 0 ) {
            throw new Exception("Invalid Generated Service Interface "
                    + serviceInterfaceName + " . ");
        } else ifseis.size() > 1 ) {
            throw new Exception("Deployment error : If no " +
                    "jaxrpc-mapping file is provided, " +
                    "Generated Service Interface must have"
                    +" only 1 Service Endpoint Interface");
        }
        String serviceEndpointInterface = (Stringseis.iterator().next();
        modelInfo.setInterfaceName(serviceEndpointInterface);
        addNamespaceMappingRegistry(modelInfomappingDesc);
        return modelInfo;
    }
    private boolean keepJaxrpcGeneratedFile(String fileTypeDescriptor desc) {
        boolean keep = true;
        if( (fileType.equals(.) ||
                fileType.equals(.)) ) {
            keep = false;
        } else iffileType.equals(. ) ) {
            // Only keep the service interface if this is a service reference
            // with generic service interface.  In this case, the interface
            // is generated during deployment instead of being packaged in
            // the module.
            keep = (desc instanceof ServiceReferenceDescriptor) &&
                    ((ServiceReferenceDescriptor)desc).hasGenericServiceInterface();
        }
        return keep;
    }
    // dummy file for jax-rpc wscompile bug
    File dummyConfigFile=null;
    private String[] createJaxrpcCompileArgs(boolean generateTies,
        boolean forceRegenthrows IOException {
        
        int numJaxrpcArgs = 11;
        if (.isLoggable(.) ) {
            numJaxrpcArgs = 16;
        }
        if (forceRegen) {
            numJaxrpcArgs--;
        }
        // If we need to run wscompile more than once per .ear or
        // standalone module, use the -infix option to reduce the
        // chances that generated non-portable jaxrpc artifacts will clash
        // with generated artifacts from other service-refs and endpoints
        // loaded by the same classloader at runtime.   
        ++;
        String infix = null;
        if > 1 ) {
            numJaxrpcArgs++;
            infix =  + "";
        }
        String[] jaxrpcArgs = new String[numJaxrpcArgs];
        int jaxrpcCnt = 0;
        if == null ) {
             = File.createTempFile("dummy_wscompile_config",
                    "config");
            .deleteOnExit();
        }
        // wscompile doesn't support the -extdirs option, so the best we
        // can do is prepend the ext dir jar files to the classpath.
        String optionalDependencyClassPath =
                InstalledLibrariesResolver.getExtDirFilesAsClasspath();
        if(optionalDependencyClassPath.length() > 0) {
             = optionalDependencyClassPath +
                    . + ;
        }
        
        // Could also check if getSourceDir() ends in 'war,' but
        // this is a little more general.
        String moduleBasePath = .getSourceDir().getAbsolutePath();
        String moduleWebInfPath = moduleBasePath +
            . + "WEB-INF" +
            . + "classes";
        File moduleWebInfFile = new File(moduleWebInfPath);
        if (moduleWebInfFile.exists()) {
             = moduleWebInfPath +
                . + ;
        } else {
             = moduleBasePath +
                . + ;
        }
        
        if (!.getScratchDir("ejb").mkdirs() && .isLoggable(.)) {
            .log(...getScratchDir("ejb"));
        }
        jaxrpcArgs[jaxrpcCnt++] = generateTies ? "-gen:server" : "-gen:client";
        // Prevent wscompile from regenerating portable classes that are
        // already packaged within the deployed application.
        if (!forceRegen) {
            jaxrpcArgs[jaxrpcCnt++] = "-f:donotoverride";
        }
        ifinfix != null ) {
            jaxrpcArgs[jaxrpcCnt++] = "-f:infix:" + infix;
        }
        jaxrpcArgs[jaxrpcCnt++] = "-classpath";
        jaxrpcArgs[jaxrpcCnt++] = ;
        if (.isLoggable(.)) {
            long timeStamp = System.currentTimeMillis();
            jaxrpcArgs[jaxrpcCnt++] = "-Xdebugmodel:" +
                    .getScratchDir("ejb") + . + "debugModel.txt." +
                    timeStamp;
            jaxrpcArgs[jaxrpcCnt++] = "-Xprintstacktrace";
            jaxrpcArgs[jaxrpcCnt++] = "-model";
            jaxrpcArgs[jaxrpcCnt++] =
                    .getScratchDir("ejb") + . + "debugModel.model" +
                            timeStamp;
            jaxrpcArgs[jaxrpcCnt++] = "-verbose";
        }
        jaxrpcArgs[jaxrpcCnt++] = "-s";
        jaxrpcArgs[jaxrpcCnt++] = .getScratchDir("ejb").getAbsolutePath();
        jaxrpcArgs[jaxrpcCnt++] = "-d";
        jaxrpcArgs[jaxrpcCnt++] = .getScratchDir("ejb").getAbsolutePath();
        jaxrpcArgs[jaxrpcCnt++] = "-keep";
        jaxrpcArgs[jaxrpcCnt++] = "-g";
        // config file is not used, but it must be an existing file or it
        // will not pass CompileTool argument validation.
        jaxrpcArgs[jaxrpcCnt++] = .getPath();
        if ( .isLoggable(.)) {
            for ( int i = 0; i < jaxrpcArgs.lengthi++ ) {
                .fine(jaxrpcArgs[i]);
            }
        }
        return jaxrpcArgs;
    }
    private void jaxrpc(String[] argsWsCompile wsCompileDescriptor desc,
                        ArrayList<Stringfiles)
            throws Exception {
        try {
            if (.isLoggable(.)) {
                debug("---> ARGS = ");
                for (int i = 0; i < args.lengthi++) {
                    .fine(args[i] + "; ");
                }
            }
            boolean compiled = wsCompile.getCompileTool().run(args);
            done(wsCompile.getCompileTool());
            ifcompiled ) {
                Iterator generatedFiles =
                        wsCompile.getGeneratedFiles().iterator();
                while(generatedFiles.hasNext()) {
                    GeneratedFileInfo next = (GeneratedFileInfo)
                            generatedFiles.next();
                    String fileType = next.getType();
                    File file = next.getFile();
                    String origPath = file.getPath();
                    iforigPath.endsWith(".java") ) {
                        int javaIndex = origPath.lastIndexOf(".java");
                        String newPath = origPath.substring(0, javaIndex) +
                                ".class";
                        ifkeepJaxrpcGeneratedFile(fileTypedesc) ) {
                            files.add(newPath);
                        }
                    }
                }
            } else {
                throw new Exception("jaxrpc compilation exception");
            }
        } catch (Throwable t) {
            Exception ge =
                    new Exception(t.getMessage());
            ge.initCause(t);
            throw ge;
        }
    }
    private void jaxrpcWebService(WebService webServiceArrayList<Stringfiles)
            throws Exception {
        if((webService.getWsdlFileUrl() == null) ||
                (webService.getMappingFileUri() == null)) {
            throw new Exception(.getLocalString(
                    "enterprise.webservice.jaxrpcFilesNotFound",
                    "Service {0} seems to be a JAXRPC based web service but without "+
                            "the mandatory WSDL and Mapping file. Deployment cannot proceed",
                    new Object[] {webService.getName()}));
        }
        ModelInfo modelInfo = createModelInfo(webService);
        String args[] = createJaxrpcCompileArgs(truefalse);
        CompileTool wscompile =
                .createCompileTool(."wscompile");
         = wscompile;
        WsCompile delegate = new WsCompile(wscompilewebService);
        delegate.setModelInfo(modelInfo);
        wscompile.setDelegate(delegate);
        jaxrpc(argsdelegatewebServicefiles);
    }
    private void debug(String msg) {
        if (.isLoggable(.) ) {
            .fine("[JaxRpcRICodegen] --> " + msg);
        }
    }
    /*
     * The run() method calls visit() on the entire application.
     * If this is being called in the context of a submodule within
     * the application, then accept(WebService) will be called
     * for every web service in the app, not just in the current
     * module. We want to ignore the unrelated web services --
     * they will be handled when their module is loaded.
     */
    private boolean webServiceInContext(WebService webService) {
        BundleDescriptor contextBundleDescriptor =
            .getModuleMetaData(BundleDescriptor.class);
        String moduleId = contextBundleDescriptor.getModuleID();
        return moduleId.equals(webService.getBundleDescriptor().getModuleID());
    }
    public void accept (BundleDescriptor descriptor) {
        if (descriptor instanceof Application) {
            Application application = (Application)descriptor;
            for (BundleDescriptor ebd : application.getBundleDescriptorsOfType(DOLUtils.ejbType())) {
                ebd.visit(getSubDescriptorVisitor(ebd));
            }
            for (BundleDescriptor wbd : application.getBundleDescriptorsOfType(DOLUtils.warType())) {
                if (wbd != null) {
                    wbd.visit(getSubDescriptorVisitor(wbd));
                }
            }
            for (BundleDescriptor acd : application.getBundleDescriptorsOfType(DOLUtils.carType())) {
                acd.visit(getSubDescriptorVisitor(acd));
            }
        } else {
            super.accept(descriptor);
        }
    }


    
visit an application object

Parameters:
the application descriptor
    public void accept(Application application) {
    }

    
visits an ejb bundle descriptor

Parameters:
an ejb bundle descriptor
    public void accept(EjbBundleDescriptor bundleDescriptor) {
    }


    
visits a appclient descriptor

Parameters:
appclientdescriptor get the visitor for its sub descriptor
sub descriptor to return visitor for
    public void accept(ApplicationClientDescriptor appclientdescriptor) {
    }

    
visit a web bundle descriptor

Parameters:
the web bundle descriptor
    public void accept(WebBundleDescriptor descriptor) {
    }
New to GrepCode? Check out our FAQ X