AppClientContainerBuilder.java

/*
 * 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.appclient.client.acc;

import com.sun.enterprise.container.common.spi.util.InjectionException;
import com.sun.enterprise.module.bootstrap.BootException;
import com.sun.enterprise.util.LocalStringManager;
import com.sun.enterprise.util.LocalStringManagerImpl;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.URLClassLoader;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.security.auth.callback.CallbackHandler;

import org.glassfish.api.naming.ClientNamingConfigurator;
import org.glassfish.appclient.client.acc.config.AuthRealm;
import org.glassfish.appclient.client.acc.config.ClientCredential;
import org.glassfish.appclient.client.acc.config.MessageSecurityConfig;
import org.glassfish.appclient.client.acc.config.Property;
import org.glassfish.appclient.client.acc.config.TargetServer;
import org.glassfish.appclient.client.acc.config.util.XML;
import org.glassfish.enterprise.iiop.api.GlassFishORBHelper;
import org.xml.sax.SAXParseException;

/**
 * Implements a builder for accumulating configuration information for the
 * app client container and then starting the ACC.
 * <p>
 * The interface for the  ACC builder is defined as AppClientContainer.Builder so the
 * relevant JavaDoc is concentrated in that one class.
 *<p>
 * The AppClientContainerBuilder class records the
 * information the container itself needs in order to operate.
 *
 * @author tjquinn
 */
public class AppClientContainerBuilder implements AppClientContainer.Builder {

    private final static String ENDPOINTS_PROPERTY_NAME = "com.sun.appserv.iiop.endpoints";

    private static final LocalStringManager localStrings = new LocalStringManagerImpl(AppClientContainerBuilder.class);
    /** caller-specified target servers */
    private TargetServer[] targetServers;

    /** caller-optional logger  - initialized to logger name from the class; caller can override with logger method */
    private Logger logger = Logger.getLogger(getClass().getName());

    private AuthRealm authRealm = null;

    private URLClassLoader classLoader = (URLClassLoader) Thread.currentThread().getContextClassLoader();

    /**
     * The caller can pre-set the client credentials using the
     * <code>clientCredentials</code> method.  The ACC will use the
     * username and realm values in intializing a callback handler if one is
     * needed.
     */
    private ClientCredential clientCredential = null;

    private boolean sendPassword = true;

    private GlassFishORBHelper orbHelper;

    /** caller-provided message security configurations */
    private final List<MessageSecurityConfig> messageSecurityConfigs = new ArrayList<MessageSecurityConfig>();

//    private Class<? extends CallbackHandler> callbackHandlerClass = null;

    /**
     * optional caller-specified properties governing the ACC's behavior.
     * Correspond to the property elements available in the client-container
     * element from sun-application-client-containerxxx.dtd.
     */
    private Properties containerProperties = null;

    AppClientContainerBuilder() {

    }
    
    /**
     * Creates a new builder with the specified target servers and client URI.
     *
     * @param targetServers the <code>TargetServer</code>s to use
     * @param clientURI the URI of the client archive to launch
     */
    AppClientContainerBuilder(final TargetServer[] targetServers) {
        this.targetServers = targetServers;
    }

    public AppClientContainer newContainer(final Class mainClass,
            final CallbackHandler callerSpecifiedCallbackHandler) throws Exception {
        prepareHabitat();
        Launchable client = Launchable.LaunchableUtil.newLaunchable(
                ACCModulesManager.getHabitat(), mainClass);
        AppClientContainer container = createContainer(client, 
                callerSpecifiedCallbackHandler, false /* istextAuth */);
        return container;
    }
    
    public AppClientContainer newContainer(final Class mainClass) throws Exception {
        return newContainer(mainClass, null);

    }

    public AppClientContainer newContainer(final URI clientURI,
            final CallbackHandler callerSpecifiedCallbackHandler,
            final String callerSpecifiedMainClassName,
            final String callerSpecifiedAppClientName) throws Exception, UserError {
        return newContainer(clientURI, callerSpecifiedCallbackHandler,
                callerSpecifiedMainClassName,
                callerSpecifiedAppClientName,
                false /* isTextAuth */);
    }

    public AppClientContainer newContainer(final URI clientURI,
            final CallbackHandler callerSpecifiedCallbackHandler,
            final String callerSpecifiedMainClassName,
            final String callerSpecifiedAppClientName,
            final boolean isTextAuth) throws Exception, UserError {
        prepareHabitat();
        prepareIIOP(targetServers, containerProperties);
        Launchable client = Launchable.LaunchableUtil.newLaunchable(
                clientURI,
                callerSpecifiedMainClassName,
                callerSpecifiedAppClientName,
                ACCModulesManager.getHabitat());

        AppClientContainer container = createContainer(client, 
                callerSpecifiedCallbackHandler, isTextAuth);
        return container;
    }

    public AppClientContainer newContainer(final URI clientURI) throws Exception, UserError {
        return newContainer(clientURI, null, null, null);
    }

    private AppClientContainer createContainer(final Launchable client,
            final CallbackHandler callerSuppliedCallbackHandler,
            final boolean isTextAuth) throws BootException, BootException, URISyntaxException, ClassNotFoundException, InstantiationException, IllegalAccessException, InjectionException, IOException, SAXParseException {
        AppClientContainer container = ACCModulesManager.getService(AppClientContainer.class);
        //process the packaged permissions.xml
        container.processPermissions();
        container.setClient(client);
        container.setBuilder(this);
        CallbackHandler callbackHandler = 
                (callerSuppliedCallbackHandler != null ? 
                    callerSuppliedCallbackHandler : getCallbackHandlerFromDescriptor(client.getDescriptor(classLoader).getCallbackHandler()));
        container.prepareSecurity(targetServers, messageSecurityConfigs, containerProperties,
                clientCredential, callbackHandler, classLoader, isTextAuth);
        return container;
    }

    private CallbackHandler getCallbackHandlerFromDescriptor(final String callbackHandlerName) throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        if (callbackHandlerName != null && ! callbackHandlerName.equals("")) {
            Class<CallbackHandler> callbackHandlerClass =
                    (Class<CallbackHandler>) Class.forName(callbackHandlerName, true, classLoader);
            return callbackHandlerClass.newInstance();
        }
        return null;
    }

    private void prepareHabitat() throws URISyntaxException {
        ACCModulesManager.initialize(Thread.currentThread().getContextClassLoader());
        orbHelper = ACCModulesManager.getService(GlassFishORBHelper.class);
    }

    /**
     * Prepares the client ORB to bootstrap into the server ORB(s) specified
     * by the TargetServer objects.
     * @param targetServers the TargetServer endpoints to which the client ORB can try to connect
     * @param containerProperties Properties, if specified, which might indicate that SSL is to be used
     * @return ORB-related properties to define host and port for bootstrapping
     */
    private void prepareIIOP(final TargetServer[] targetServers, Properties containerProperties) {
        if (targetServers.length == 0) {
            throw new IllegalArgumentException();
        }

        final StringBuilder sb = new StringBuilder();
        for (TargetServer ts : targetServers) {
            if (sb.length() > 0) {
                sb.append(",");
            }
            sb.append(ts.getAddress()).append(":").append(ts.getPort());
        }

        /*
         * If the user has explicitly defined the ORB-related properties, do
         * not override those settings.
         */
        if (targetServers.length == 1) {
            defineIfNotDefined(GlassFishORBHelper.OMG_ORB_INIT_HOST_PROPERTY,
                    targetServers[0].getAddress());
            defineIfNotDefined(GlassFishORBHelper.OMG_ORB_INIT_PORT_PROPERTY,
                    Integer.toString(targetServers[0].getPort()));
        } else {
            /*
             * Currently, set a system property to specify multiple endpoints.
             */
            defineIfNotDefined(ENDPOINTS_PROPERTY_NAME, sb.toString());
        }

        if (isSSLRequired(targetServers, containerProperties)) {
            orbHelper.setCSIv2Prop(GlassFishORBHelper.ORB_SSL_CLIENT_REQUIRED, "true");
        }
        logger.log(Level.CONFIG, "Using endpoint address(es): {0}", sb.toString());

    }

    /**
     * Define the specified system property using the new value unless the
     * property is already set.
     * @param propName name of the property to check and, possibly, set
     * @param newPropValue value to set if the property is not already set
     */
    private void defineIfNotDefined(final String propName, final String newPropValue) {
        if (System.getProperty(propName) == null) {
            if (newPropValue == null) {
                throw new RuntimeException(localStrings.getLocalString(
                        AppClientContainerBuilder.class,
                        "appclient.missingValue", 
                        "Value for {0} expected but was not configured or assigned",
                        new Object[] {propName}
                        ));
                        
            }
            System.setProperty(propName, newPropValue);
        }
    }

    /**
     * Reports whether the ORB should be requested to use SSL.
     * <p>
     * If any TargetServer specifies SSL or the container-level properties
     * specify SSL then report "true."
     * @param targetServers configured TargetServer(s)
     * @param containerProperties configured container-level properties
     * @return whether the target servers or the properties implies the use of SSL
     */
    private boolean isSSLRequired(final TargetServer[] targetServers, final Properties containerProperties) {
        if (containerProperties != null) {
            String sslPropertyValue = containerProperties.getProperty("ssl");
            if ("required".equals(sslPropertyValue)) {
                return true;
            }
        }
        for (TargetServer ts : targetServers) {
            /*
             * If this target server has the optional security sub-item then
             * the security sub-item must have an ssl sub-item.  So we can just
             * look for the security sub-item.
             */
            if (ts.getSecurity() != null) {
                return true;
            }
        }
        return false;
    }


//    /**
//     * Returns an AppClientContainer prepared to execute the app client implied
//     * by the launch info and the app client args.
//     * @param launchInfo info about the launch (type, name)
//     * @param appclientArgs appclient command line arguments
//     * @return
//     */
//    AppClientContainer newContainer(final CommandLaunchInfo launchInfo, final AppclientCommandArguments appclientArgs) {
//        AppClientContainer acc = null;
////        switch (launchInfo.getClientLaunchType()) {
////            case JAR:
////                /*
////                 * The user will have used local file path syntax, so create a
////                 * file first and then get its URI.
////                 */
////                File f = new File(launchInfo.getClientName());
////                acc = newContainer(f.toURI());
////
////                StandAloneAppClientInfo acInfo = new StandAloneAppClientInfo(
////                        false /* isJWS */,
////                        logger,
////                        f, archivist, mainClassFromCommandLine)
////        }
//        return acc;
//    }

    public AppClientContainerBuilder addMessageSecurityConfig(final MessageSecurityConfig msConfig) {
        messageSecurityConfigs.add(msConfig);
        return this;
    }

    public List<MessageSecurityConfig> getMessageSecurityConfig() {
        return this.messageSecurityConfigs;
    }

    public AppClientContainerBuilder logger(final Logger logger) {
        this.logger = logger;
        return this;
    }

    public Logger getLogger() {
        return logger;
    }


    public AppClientContainerBuilder authRealm(final String className) {
        authRealm = new AuthRealm(className);
        return this;
    }

    public AuthRealm getAuthRealm() {
        return authRealm;
    }

    public AppClientContainerBuilder clientCredentials(final String user, final char[] password) {
        return clientCredentials(user, password, null);
    }

    public AppClientContainerBuilder clientCredentials(final String user, final char[] password, final String realm) {
//        this.clientCredential = new ClientCredential()
//        this.user = user;
//        this.password = password;
//        this.realmName = realm;
        ClientCredential cc = new ClientCredential(user, new XML.Password(password), realm);
        return clientCredentials(cc);
    }

    public AppClientContainerBuilder clientCredentials(final ClientCredential cc) {
        clientCredential = cc;
        return this;
    }

    public ClientCredential getClientCredential() {
        return clientCredential;
    }

    public AppClientContainerBuilder containerProperties(final Properties props) {
        this.containerProperties = props;
        return this;
    }

    public AppClientContainerBuilder containerProperties(final List<Property> props) {
        containerProperties = XML.toProperties(props);
        return this;
    }

    public Properties getContainerProperties() {
        return containerProperties;
    }

    public AppClientContainerBuilder sendPassword(final boolean sendPassword){
        this.sendPassword = sendPassword;
        return this;
    }

    public boolean getSendPassword() {
        return sendPassword;
    }

//    public AppClientContainerBuilder callbackHandler(final Class<? extends CallbackHandler> callbackHandlerClass) {
//        this.callbackHandlerClass = callbackHandlerClass;
//        return this;
//    }

//    public Class<? extends CallbackHandler> getCallbackHandler() {
//        return callbackHandlerClass;
//    }

    public TargetServer[] getTargetServers() {
        return targetServers;
    }

//    public AppClientContainerBuilder mainClass(Class mainClass) {
//        this.mainClass = mainClass;
//        return this;
//    }

//    public Class getMainClass() {
//        return mainClass;
//    }
//
//    public AppClientContainerBuilder mainClassName(String mainClassName) {
//        if (isMainClassFromCaller) {
//            throw new IllegalStateException();
//        }
//        this.mainClassName = mainClassName;
//        return this;
//    }
//
//    public String getMainClassName() {
//        return mainClassName;
//    }
//
//    public AppClientContainerBuilder mainClass(final Class mainClass) {
//        this.mainClass = mainClass;
//        mainClassName = mainClass.getName();
//        return this;
//    }
//
//    public Method getMainMethod() {
//        return mainMethod;
//    }
//
//    private void completeConfig() throws NoSuchMethodException {
//        mainMethod = initMainMethod();
//    }
//

}