StandaloneProcessor.java

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright (c) 2005-2017 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://oss.oracle.com/licenses/CDDL+GPL-1.1
 * or 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 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.
 */

/*
 * StandaloneProcessor.java
 *
 * Created on January 7, 2005, 9:26 AM
 */

package devtests.deployment.util;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.logging.*;

import javax.enterprise.deploy.shared.ModuleType;

import com.sun.enterprise.deployment.ApplicationClientDescriptor;
import com.sun.enterprise.deployment.BundleDescriptor;
import org.glassfish.ejb.deployment.descriptor.EjbBundleDescriptorImpl;
import com.sun.enterprise.deployment.WebBundleDescriptor;
import com.sun.enterprise.deployment.WebComponentDescriptor;

import org.glassfish.apf.AnnotatedElementHandler;
import org.glassfish.apf.AnnotationHandler;
import org.glassfish.apf.AnnotationProcessor;
import org.glassfish.apf.ProcessingContext;
import org.glassfish.apf.ProcessingResult;
import org.glassfish.apf.Scanner;
import com.sun.enterprise.deployment.annotation.context.AppClientContext;
import com.sun.enterprise.deployment.annotation.context.EjbBundleContext;
import com.sun.enterprise.deployment.annotation.context.WebBundleContext;
import com.sun.enterprise.deployment.annotation.factory.SJSASFactory;
import org.glassfish.apf.impl.AnnotationUtils;
import com.sun.enterprise.deployment.annotation.impl.AppClientScanner;
import org.glassfish.apf.impl.DirectoryScanner;
import org.glassfish.ejb.deployment.annotation.impl.EjbJarScanner;
import org.glassfish.web.deployment.annotation.impl.WarScanner;
import org.glassfish.web.deployment.descriptor.WebBundleDescriptorImpl;
import org.glassfish.web.deployment.descriptor.WebComponentDescriptorImpl;
import com.sun.enterprise.deployment.annotation.impl.ModuleScanner;

import com.sun.enterprise.deployment.io.AppClientDeploymentDescriptorFile;
import org.glassfish.ejb.deployment.io.EjbDeploymentDescriptorFile;
import org.glassfish.web.deployment.io.WebDeploymentDescriptorFile;
import org.glassfish.webservices.io.WebServicesDeploymentDescriptorFile;

import com.sun.enterprise.deployment.util.ApplicationValidator;
import com.sun.enterprise.deployment.util.AppClientVisitor;
import com.sun.enterprise.deployment.util.AppClientValidator;
import org.glassfish.ejb.deployment.util.EjbBundleValidator;
import com.sun.enterprise.deployment.util.EjbBundleVisitor;
import org.glassfish.web.deployment.util.WebBundleVisitor;
import org.glassfish.web.deployment.util.WebBundleValidator;

import org.glassfish.api.deployment.archive.ReadableArchive;
import com.sun.enterprise.deploy.shared.ArchiveFactory;
import com.sun.enterprise.module.ModulesRegistry;
import org.glassfish.hk2.api.ServiceLocator;
import org.glassfish.hk2.utilities.ServiceLocatorUtilities;
import com.sun.enterprise.module.single.StaticModulesRegistry;
import com.sun.enterprise.module.bootstrap.StartupContext;
import org.glassfish.api.admin.ProcessEnvironment;
import org.glassfish.api.admin.ProcessEnvironment.ProcessType;


/**
 *
 * @author dochez
 */
public class StandaloneProcessor {
    private BundleDescriptor bundleDescriptor = null;
    private AnnotatedElementHandler aeHandler = null;
    private ModuleType type = null;
    private Set<String> compClassNames = null;
    private static ServiceLocator serviceLocator = null;
    
    /** Creates a new instance of StandaloneProcessor */
    public StandaloneProcessor() {
        this(ModuleType.EJB);
    }

    public StandaloneProcessor(ModuleType type) {
        this.type = type;
        if (ModuleType.EJB.equals(type)) {
            bundleDescriptor = new EjbBundleDescriptorImpl();
            aeHandler = new EjbBundleContext((EjbBundleDescriptorImpl) bundleDescriptor);
           
        } else if (ModuleType.WAR.equals(type)) {
            bundleDescriptor = new WebBundleDescriptorImpl();
            aeHandler = new WebBundleContext(
                    (WebBundleDescriptor)bundleDescriptor);
        } else if (ModuleType.CAR.equals(type)) {
            bundleDescriptor = new ApplicationClientDescriptor();
            aeHandler = new AppClientContext(
                    (ApplicationClientDescriptor)bundleDescriptor);
        } else {
            throw new UnsupportedOperationException(
                    "ModuleType : " + type + " is not supported.");
        }
    }

    public void setComponentClassNames(Set compClassNames) {
        this.compClassNames = compClassNames;
    }
    
    public static void main(String[] args) throws Exception {
        StandaloneProcessor processor = new StandaloneProcessor();
        processor.run(args);
        processor.generateEjbJarXmlFile(".");
        processor.generateWebServicesXmlFile(".");
    }
    
    public int run(String[] args) throws Exception {
        for (String arg : args) {
            System.out.println("Annotation log is set to " + System.getProperty("annotation.log"));
            String logWhat = System.getProperty("annotation.log");
            if (logWhat!=null) {
                AnnotationUtils.setLoggerTarget(logWhat);
                initLogger();
            }            
            AnnotationUtils.getLogger().info("processing " + arg);
            File f = new File(arg);
            if (f.exists()) {
                try {
                    prepareServiceLocator();
                    ArchiveFactory archiveFactory = serviceLocator.getService(ArchiveFactory.class);
                    ReadableArchive archive = archiveFactory.openArchive(f);
                    ClassLoader classLoader = null;
                    if (ModuleType.WAR.equals(type)) {
                        classLoader = new URLClassLoader(
                            new URL[] { new File(f, "WEB-INF/classes").toURL() });
                    } else {
                        classLoader = new URLClassLoader(new URL[]{ f.toURL() });
                    }
                    ModuleScanner scanner = null;

                    if (ModuleType.EJB.equals(type)) {
                        EjbBundleDescriptorImpl ejbBundleDesc =
                                (EjbBundleDescriptorImpl)bundleDescriptor;
                        scanner = serviceLocator.getService(EjbJarScanner.class);
                        scanner.process(archive, ejbBundleDesc, classLoader, null);
                        
                    } else if (ModuleType.WAR.equals(type)) {
                        WebBundleDescriptor webBundleDesc =
                                (WebBundleDescriptor)bundleDescriptor;
                        for (String cname : compClassNames) {
                            WebComponentDescriptor webCompDesc =
                                    new WebComponentDescriptorImpl();
                            webCompDesc.setServlet(true);
                            webCompDesc.setWebComponentImplementation(cname);
                            webBundleDesc.addWebComponentDescriptor(webCompDesc);
                        }
                        scanner = serviceLocator.getService(WarScanner.class);
                        scanner.process(archive, webBundleDesc, classLoader, null);
                        
                    } else if (ModuleType.CAR.equals(type)) {
                        String mainClassName = compClassNames.iterator().next();
                        ApplicationClientDescriptor appClientDesc = 
                                (ApplicationClientDescriptor)bundleDescriptor;
                        appClientDesc.setMainClassName(mainClassName);
                        scanner = serviceLocator.getService(AppClientScanner.class);
                        scanner.process(archive, appClientDesc, classLoader, null);
                        
                    }

                    AnnotationProcessor ap = serviceLocator.<SJSASFactory>getService(SJSASFactory.class).getAnnotationProcessor();
                    
                    
                    // if the user indicated a directory for handlers, time to add the                    
                    String handlersDir = System.getProperty("handlers.dir");
                    if (handlersDir!=null) {
                        addHandlers(ap, handlersDir);
                    }
                    
                    ProcessingContext ctx = ap.createContext();
                    ctx.setErrorHandler(new StandaloneErrorHandler());
                    bundleDescriptor.setClassLoader(scanner.getClassLoader());
                    ctx.setProcessingInput(scanner);
                    ctx.pushHandler(aeHandler);
                    ProcessingResult result = ap.process(ctx);
                    if (ModuleType.EJB.equals(type)) {
                        EjbBundleDescriptorImpl ebd = (EjbBundleDescriptorImpl)bundleDescriptor;
                        ebd.visit(new EjbBundleValidator());
                    } else if (ModuleType.WAR.equals(type)) {
                        WebBundleDescriptor wbd = (WebBundleDescriptor)bundleDescriptor;
                        wbd.visit(new WebBundleValidator());
                    } else if (ModuleType.CAR.equals(type)) {
                        ApplicationClientDescriptor acbd = (ApplicationClientDescriptor)bundleDescriptor;
                        acbd.visit(new AppClientValidator());
                    }
                    // display the result ejb bundle...
                    // AnnotationUtils.getLogger().info("Resulting " + bundleDescriptor);

                } catch(Exception e) {
                    e.printStackTrace();
                    throw e;
                }
            }
        }
        return 0;
    }

    public void generateAppClientXmlFile(String dir) throws IOException {
         AppClientDeploymentDescriptorFile appClientdf = new AppClientDeploymentDescriptorFile();
         appClientdf.write(bundleDescriptor, dir);
    
    }

    public void generateEjbJarXmlFile(String dir) throws IOException {
         EjbDeploymentDescriptorFile ejbdf = new EjbDeploymentDescriptorFile();
         ejbdf.write(bundleDescriptor, dir);
    
    }

    public void generateWebXmlFile(String dir) throws IOException {
         WebDeploymentDescriptorFile webdf = new WebDeploymentDescriptorFile();
         webdf.write((WebBundleDescriptorImpl)bundleDescriptor, dir);
    }

    public void generateWebServicesXmlFile(String dir) throws IOException {
         WebServicesDeploymentDescriptorFile ddf = new WebServicesDeploymentDescriptorFile(bundleDescriptor);
         ddf.write(bundleDescriptor, dir);
    }
    
    private void addHandlers(AnnotationProcessor ap, String handlersDir) {
        try {
        System.out.println("Handlers dir set at " + handlersDir);
        DirectoryScanner scanner = new DirectoryScanner();
        scanner.process(new File(handlersDir),null,null);
        
        Set<Class> elements = scanner.getElements();
        for (Class handlerClass : elements) {
            Class[] interfaces = handlerClass.getInterfaces();
            for (Class interf : interfaces) {
                if (interf.equals(org.glassfish.apf.AnnotationHandler.class)) {
                    AnnotationHandler handler = (AnnotationHandler) handlerClass.newInstance();
                    if (AnnotationUtils.shouldLog("handler")) {
                        AnnotationUtils.getLogger().fine("Registering handler " + handlerClass 
                               + " for type " + handler.getAnnotationType());
                    }
                    ap.pushAnnotationHandler(handler);
                }
            }
        }
        } catch(Exception e) {
            AnnotationUtils.getLogger().severe("Exception while registering handlers : " + e.getMessage());
        }
    }
    
    private void initLogger() {
        try {
            FileHandler handler = new FileHandler("annotation.log");
            handler.setFormatter(new LogFormatter());
            handler.setLevel(Level.FINE);
            Logger logger = Logger.global;
            logger.setLevel(Level.FINE);
            logger.addHandler(handler);} catch(Exception e) {
                e.printStackTrace();
            }       
    }

    private void prepareServiceLocator() {
        if ( (serviceLocator == null) ) {
            // Bootstrap a hk2 environment.
            ModulesRegistry registry = new StaticModulesRegistry(getClass().getClassLoader());
            serviceLocator = registry.createServiceLocator("default");
            
            StartupContext startupContext = new StartupContext();

            ServiceLocatorUtilities.addOneConstant(serviceLocator, startupContext);
            ServiceLocatorUtilities.addOneConstant(serviceLocator,
                new ProcessEnvironment(ProcessEnvironment.ProcessType.Other));
        }
    }

}