Glassfish example source code file (AppClientContainerBuilder.java)

This example Glassfish source code file (AppClientContainerBuilder.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Java - Glassfish tags/keywords

appclientcontainer, appclientcontainer, appclientcontainerbuilder, appclientcontainerbuilder, callbackhandler, class, clientcredential, exception, io, log, logging, net, network, properties, string, string, targetserver, targetserver, uri, util

The Glassfish AppClientContainerBuilder.java source code

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright (c) 1997-2010 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.jvnet.hk2.component.Habitat;
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 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();

//    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>TargetServers 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.getComponent(AppClientContainer.class);
        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.getComponent(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) {
            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();
//    }
//

}