EJBContainerImpl.java

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright (c) 2009-2012 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.ejb.embedded;

import java.io.File;
import java.util.Map;
import java.util.Set;
import java.util.logging.Logger;
import java.util.logging.Level;

import javax.naming.Context;
import javax.naming.InitialContext;
import javax.ejb.embeddable.EJBContainer;
import javax.ejb.EJBException;
import javax.transaction.TransactionManager;

import com.sun.logging.LogDomains;
import com.sun.ejb.containers.EjbContainerUtilImpl;
import com.sun.appserv.connectors.internal.api.ConnectorRuntime;
import com.sun.enterprise.util.io.FileUtils;

import org.glassfish.embeddable.Deployer;
import org.glassfish.embeddable.GlassFish;
import org.glassfish.embeddable.GlassFishException;
import org.glassfish.embeddable.archive.ScatteredArchive;
import org.glassfish.hk2.api.ServiceHandle;
import org.glassfish.hk2.api.ServiceLocator;

/**
 * GlassFish implementation of the EJBContainer.
 *
 * @author Marina Vatkina
 */
public class EJBContainerImpl extends EJBContainer {

    // Use Bundle from another package
    private static final Logger _logger =
            LogDomains.getLogger(EjbContainerUtilImpl.class, LogDomains.EJB_LOGGER);

    private final GlassFish server;
    
    private final Deployer deployer;

    private String deployedAppName;

    private ServiceLocator habitat;

    private volatile int state = STARTING;
    private Cleanup cleanup = null;
    private DeploymentElement.ResultApplication res_app;

    private final static int STARTING = 0;
    private final static int RUNNING = 1;
    private final static int CLOSING = 2;
    private final static int CLOSED = 3;

    /**
     * Construct new EJBContainerImpl instance 
     */                                               
    EJBContainerImpl(GlassFish server) throws GlassFishException {
        this.server = server;
        this.server.start();

        this.habitat = server.getService(ServiceLocator.class);
        deployer = server.getDeployer();
        state = RUNNING;
        cleanup = new Cleanup(this);
    }

    /**
     * Construct new EJBContainerImpl instance and deploy found modules.
     */
    void deploy(Map<?, ?> properties, Set<DeploymentElement> modules) throws EJBException {
        try {
            String appName = (properties == null)? null : (String)properties.get(EJBContainer.APP_NAME);
            res_app = DeploymentElement.getOrCreateApplication(modules, appName);
            Object app = res_app.getApplication();

            if (app == null) {
                throw new EJBException("Invalid set of modules to deploy - see log for details");
            }

            if (_logger.isLoggable(Level.INFO)) {
                _logger.info("[EJBContainerImpl] Deploying app: " + app);
            }

            // Check if appName was set by application creation code
            appName = res_app.getAppName();
            
            String[] params;
            if (appName != null) {
                params = new String[] {"--name", appName};
            } else {
                params = new String[] {};
            }

            _logger.info("[EJBContainerImpl] GlassFish status: " + server.getStatus());
            if (app instanceof ScatteredArchive) {
                _logger.info("[EJBContainerImpl] Deploying as a ScatteredArchive");
                deployedAppName = deployer.deploy(((ScatteredArchive)app).toURI(), params);
            } else {
                _logger.info("[EJBContainerImpl] Deploying as a File");
                deployedAppName = deployer.deploy((File)app, params);
            }

        } catch (Exception e) {
            throw new EJBException("Failed to deploy EJB modules", e);
        }

        if (deployedAppName == null) {
            throw new EJBException("Failed to deploy EJB modules - see log for details");
        }
    }

    /**
     * Retrieve a naming context for looking up references to session beans
     * executing in the embeddable container.
     *
     * @return naming context
     */
    public Context getContext() { 
        if (_logger.isLoggable(Level.FINE)) {
            _logger.fine("IN getContext()");
        }
        try {
            return new InitialContext();
        } catch (Exception e) {
            throw new EJBException(_logger.getResourceBundle().getString(
                    "ejb.embedded.cannot_create_context"), e);
        }
    }

    /**
     * Shutdown an embeddable EJBContainer instance.
     */
    public void close() {
        if (cleanup != null) {
            cleanup.disable();
        }
        if (isOpen()) {
            forceClose();
        }
    }

    void forceClose() {
        state = CLOSING;

        if (_logger.isLoggable(Level.FINE)) {
            _logger.fine("IN close()");
        }

        undeploy();
        cleanupTransactions();
        cleanupConnectorRuntime();
        if (res_app != null && res_app.deleteOnExit()) {
            try {
                FileUtils.whack((File)res_app.getApplication());
            } catch (Exception e) {
                _logger.log(Level.WARNING, "Error in removing temp file", e);
            }
        }
        stop();
    }

    /**
     * Returns true if there are deployed modules associated with this container.
     */
    boolean isOpen() {
        return state == RUNNING;
    }

    private void cleanupTransactions() {
        try {
            /*
            Providers<TransactionManager> txProviders = habitat.forContract(TransactionManager.class);
            if (txProviders != null) {
                Provider<TransactionManager> provider = txProviders.getProvider();
                if (provider != null && provider.isActive()) {
                    TransactionManager txMgr = provider.get();
                    txMgr.rollback();
                }
            }
            */
            ServiceHandle<TransactionManager> inhabitant =
                    habitat.getServiceHandle(TransactionManager.class);
            if (inhabitant != null && inhabitant.isActive()) {
                TransactionManager txmgr = inhabitant.getService();
                if ( txmgr.getTransaction() != null ) {
                    txmgr.rollback();
                }
            }
        } catch (Throwable t) {
            _logger.log(Level.SEVERE, "Error in cleanupTransactions", t);
        }

    }

    private void cleanupConnectorRuntime() {
        try {
            /*
            Providers<ConnectorRuntime> txProviders = habitat.forContract(ConnectorRuntime.class);
            if (txProviders != null) {
                Provider<ConnectorRuntime> provider = txProviders.getProvider();
                if (provider != null && provider.isActive()) {
                    ConnectorRuntime connectorRuntime = provider.get();
                    connectorRuntime.cleanUpResourcesAndShutdownAllActiveRAs();
                }
            }
            */
            ServiceHandle<ConnectorRuntime> inhabitant =
                    habitat.getServiceHandle(ConnectorRuntime.class);
            if (inhabitant != null && inhabitant.isActive()) {
                ConnectorRuntime connectorRuntime = inhabitant.getService();
                connectorRuntime.cleanUpResourcesAndShutdownAllActiveRAs();
            }
        } catch (Throwable t) {
            _logger.log(Level.SEVERE, "Error in cleanupConnectorRuntime", t);
        }
    }

    private void undeploy() {
        if (deployedAppName != null) {
            try {
                deployer.undeploy(deployedAppName);
            } catch (Exception e) {
                _logger.warning("Cannot undeploy deployed modules: " + e.getMessage());
            }
        }
    }

    void stop() {
        if (state == CLOSED) {
            return;
        }
        try {
            server.stop();
        } catch (GlassFishException e) {
            _logger.log(Level.WARNING, "Cannot stop embedded server", e);
        } finally {
            try {
                server.dispose();
            } catch (GlassFishException e) {
                _logger.log(Level.WARNING, "Cannot dispose embedded server", e);
            }
            state = CLOSED;
        }
    }

    private static class Cleanup implements Runnable {

        private Thread cleanupThread = null;
        private EJBContainerImpl container = null;

        Cleanup(EJBContainerImpl container) {
            this.container = container;
            Runtime.getRuntime().addShutdownHook(
                    cleanupThread = new Thread(this, "EJBContainerImplCleanup"));
        }

        void disable() {
            java.security.AccessController.doPrivileged(
                new java.security.PrivilegedAction() {
                    @Override
                    public Object run() {
                        Runtime.getRuntime().removeShutdownHook(cleanupThread);
                        return null;
                    }
                }
            );
        }

        public void run() {
            if (container.isOpen()) {
                container.forceClose();
            }
        }
    }
}