|
|
Glassfish example source code file (Main.java)
This example Glassfish source code file (Main.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.
The Glassfish Main.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.appserv.naming.S1ASCtxFactory;
//import com.sun.enterprise.appclient.AppContainer;
//import com.sun.enterprise.appclient.HttpAuthenticator;
//import com.sun.enterprise.appclient.jws.TemplateCache;
//import com.sun.enterprise.appclient.jws.Util;
//import com.sun.enterprise.appclient.jws.boot.ClassPathManager;
//import com.sun.enterprise.config.clientbeans.CertDb;
//import com.sun.enterprise.config.clientbeans.ClientBeansFactory;
//import com.sun.enterprise.config.clientbeans.ClientContainer;
//import com.sun.enterprise.config.clientbeans.ClientCredential;
//import com.sun.enterprise.config.clientbeans.ElementProperty;
//import com.sun.enterprise.config.clientbeans.Security;
//import com.sun.enterprise.config.clientbeans.Ssl;
//import com.sun.enterprise.config.clientbeans.TargetServer;
//import com.sun.enterprise.config.ConfigContext;
//import com.sun.enterprise.config.ConfigException;
//import com.sun.enterprise.config.ConfigFactory;
//import com.sun.enterprise.connectors.ActiveResourceAdapter;
//import com.sun.enterprise.connectors.ConnectorRegistry;
//import com.sun.enterprise.connectors.ConnectorRuntime;
//import com.sun.enterprise.deployment.*;
//import com.sun.enterprise.deployment.archivist.AppClientArchivist;
//import com.sun.enterprise.deployment.archivist.ApplicationArchivist;
//import com.sun.enterprise.deployment.archivist.Archivist;
//import com.sun.enterprise.deployment.archivist.ArchivistFactory;
//import com.sun.enterprise.deployment.deploy.shared.AbstractArchive;
//import com.sun.enterprise.deployment.deploy.shared.Archive;
//import com.sun.enterprise.deployment.deploy.shared.ArchiveFactory;
//import com.sun.enterprise.deployment.deploy.shared.FileArchive;
//import com.sun.enterprise.deployment.deploy.shared.InputJarArchive;
//import com.sun.enterprise.deployment.interfaces.SecurityRoleMapperFactory;
//import com.sun.enterprise.deployment.interfaces.SecurityRoleMapperFactoryMgr;
//import com.sun.enterprise.util.SystemPropertyConstants;
//import com.sun.enterprise.webservice.ClientPipeCloser;
//import com.sun.enterprise.InjectionManager;
//import com.sun.enterprise.J2EESecurityManager;
//import com.sun.enterprise.loader.ASURLClassLoader;
//import com.sun.enterprise.loader.InstrumentableClassLoader;
//import com.sun.enterprise.naming.ProviderManager;
//import com.sun.enterprise.security.GUIErrorDialog;
//import com.sun.enterprise.security.SSLUtils;
//import com.sun.enterprise.server.logging.ACCLogManager;
//import com.sun.enterprise.Switch;
//import com.sun.enterprise.util.FileUtil;
//import com.sun.enterprise.util.i18n.StringManager;
//import com.sun.enterprise.util.JarClassLoader;
//import com.sun.enterprise.util.ORBManager;
//import com.sun.enterprise.util.shared.ArchivistUtils;
//import com.sun.enterprise.util.Utility;
//import com.sun.logging.LogDomains;
//import com.sun.web.server.HttpsURLStreamHandlerFactory;
//import java.awt.EventQueue;
//import java.awt.Toolkit;
//
//import java.io.*;
//import java.lang.reflect.InvocationTargetException;
//import java.net.*;
//import java.text.MessageFormat;
//import java.util.ArrayList;
//import java.util.Iterator;
//import java.util.Set;
//import java.util.concurrent.atomic.AtomicInteger;
//import java.util.jar.JarFile;
//import java.util.logging.Handler;
//import java.util.logging.Level;
//import java.util.logging.LogRecord;
//import java.util.logging.Logger;
//import java.util.logging.LogManager;
//import java.util.Properties;
//import java.util.Vector;
//import java.util.logging.MemoryHandler;
//import java.util.logging.SimpleFormatter;
//import javax.enterprise.deploy.shared.ModuleType;
//import javax.naming.InitialContext;
//
//import javax.security.auth.message.config.AuthConfigFactory;
//import com.sun.enterprise.security.jmac.config.GFAuthConfigFactory;
//import com.sun.enterprise.deployment.ServiceReferenceDescriptor;
//import com.sun.enterprise.security.UsernamePasswordStore;
//import javax.swing.SwingUtilities;
/**
* This is the main program invoked from the command line.
*
* It processes the command line arguments to prepare the Map of options, then
* passes the Map to an instance of the embedded ACC.
*/
public class Main {
private static final String CLIENT = "-client";
private static final String NAME = "-name";
private static final String MAIN_CLASS = "-mainclass";
private static final String TEXT_AUTH = "-textauth";
private static final String XML_PATH = "-xml";
private static final String ACC_CONFIG_XML = "-configxml";
private static final String DEFAULT_CLIENT_CONTAINER_XML = "sun-acc.xml";
// duplicated in com.sun.enterprise.jauth.ConfigXMLParser
private static final String SUNACC_XML_URL = "sun-acc.xml.url";
private static final String NO_APP_INVOKE = "-noappinvoke";
//Added for allow user to pass user name and password through command line.
private static final String USER = "-user";
private static final String PASSWORD = "-password";
private static final String PASSWORD_FILE = "-passwordfile";
private static final String LOGIN_NAME = "j2eelogin.name";
private static final String LOGIN_PASSWORD = "j2eelogin.password";
private static final String DASH = "-";
private static final String lineSep = System.getProperty("line.separator");
// /**
// * Property names used on the server to send these values to a Java Web Start client
// * and by the ACC when running under Java Web Start to retrieve them
// */
// public static final String APPCLIENT_IIOP_DEFAULTHOST_PROPERTYNAME = "com.sun.aas.jws.iiop.defaultHost";
// public static final String APPCLIENT_IIOP_DEFAULTPORT_PROPERTYNAME = "com.sun.aas.jws.iiop.defaultPort";
// public static final String APPCLIENT_IIOP_FAILOVER_ENDPOINTS_PROPERTYNAME = "com.sun.aas.jws.iiop.failover.endpoints";
// public static final String APPCLIENT_PROBE_CLASSNAME_PROPERTYNAME = "com.sun.aas.jws.probeClassName";
//
// /** Prop name for keeping temporary files */
// public static final String APPCLIENT_RETAIN_TEMP_FILES_PROPERTYNAME = "com.sun.aas.jws.retainTempFiles";
//
// /** property name used to indicate that Java Web Start is active */
// public static final String APPCLIENT_ISJWS_PROPERTYNAME = "com.sun.aas.jws.isJWS";
//
// /** property name used to indicate the Java Web Start download host name */
// public static final String APPCLIENT_DOWNLOAD_HOST_PROPERTYNAME = "com.sun.aas.jws.download.host";
// /** Prop used when running under Java Web Start to point to a temporarily-created default file.
// *This property appears in the template for the default sun-acc.xml content. Logic below
// *assigns a value to it and then uses it to substitute in the template to create the
// *actual content. (This is not a property set in the environment and then retrieved by Main.)
// */
// public static final String SUN_ACC_SECURITY_CONFIG_PROPERTY = "security.config.file";
//
// /** Used for constructing the name of the temp file that will hold the login conf. content */
// private static final String LOGIN_CONF_FILE_PREFIX = "login";
// private static final String LOGIN_CONF_FILE_SUFFIX = ".conf";
//
// /** The system property to be set that is later read by jaas */
// private static final String LOGIN_CONF_PROPERTY_NAME = "java.security.auth.login.config";
//
// /** Names of templates for default config for Java Web Start */
// private static final String DEFAULT_TEMPLATE_PREFIX = "jws/templates/";
// private static final String SUN_ACC_DEFAULT_TEMPLATE = DEFAULT_TEMPLATE_PREFIX + "default-sun-accTemplate.xml";
// private static final String WSS_CLIENT_CONFIG_TEMPLATE = DEFAULT_TEMPLATE_PREFIX + "default-wss-client-configTemplate.xml";
// private static final String LOGIN_CONF_TEMPLATE = DEFAULT_TEMPLATE_PREFIX + "appclientlogin.conf";
//
// /** Naming for temporary files created under Java Web Start */
// private static final String WSS_CLIENT_CONFIG_PREFIX = "wsscc";
// private static final String WSS_CLIENT_CONFIG_SUFFIX = ".xml";
// private static final String SUN_ACC_PREFIX = "sunacc";
// private static final String SUN_ACC_SUFFIX = ".xml";
//
// /** Paths to persistence JARs added to the classpath for the class loader created by the ACC */
// private static final String [] LOCAL_LAUNCH_PERSISTENCE_JAR_PATHS = new String[] {
// System.getProperty(SystemPropertyConstants.DERBY_ROOT_PROPERTY) + File.separator + "lib" + File.separator + "derbyclient.jar",
// System.getProperty(SystemPropertyConstants.INSTALL_ROOT_PROPERTY) + File.separator + "lib" + File.separator + "toplink-essentials.jar",
// System.getProperty(SystemPropertyConstants.INSTALL_ROOT_PROPERTY) + File.separator + "lib" + File.separator + "dbschema.jar"};
//
// private static final String ORB_INITIAL_HOST_PROPERTYNAME = "org.omg.CORBA.ORBInitialHost";
// private static final String ORB_INITIAL_PORT_PROPERTYNAME = "org.omg.CORBA.ORBInitialPort";
//
// protected static Logger _logger;
//
// protected final boolean debug = false;
// protected StringManager localStrings =
// StringManager.getManager(Main.class);
// protected boolean guiAuth = false; // unless the user sets the auth.gui prop and does not use -textauth
// protected boolean runClient=true;
//
// protected String host;
//
// protected String port;
//
// /** Saved arguments so they are accessible from the AWT thread if needed */
// protected String [] args;
//
// /** Records whether ACC is currently running under Java Web Start */
// protected boolean isJWS;
//
// /** Records whether temp config files created while running under Java Web Start should be retained */
// protected boolean retainTempFiles = false;
//
// protected String clientJar = null;
// protected String displayName = null;
// protected String mainClass = null;
// protected String xmlPath = null;
// protected String accConfigXml = null;
// protected String jwsACCConfigXml = null;
// protected Vector<String> appArgs = new Vector();
// protected String classFileFromCommandLine = null;
// protected boolean useTextAuth = false;
//
// private static boolean lb_enabled = false;
//
// /**
// * Indicates whether ORB load balancing is turned on.
// *<p>
// * Should not be invoked until after setTargetServerProperties has been
// * invoked. This method is intended for use by ORB initializers, which in
// * turn are run during the instantiation of the InitialContext. The
// * InitialContext is created (in the constructor for this class) after
// * setTargetServerProperties has been run, so this precondition should
// * be met.
// * @return true if load balancing was specified or implied, false otherwise
// */
// public static boolean isLoadBalancingEnabled() {
// return lb_enabled;
// }
//
// public Main(String[] args) {
// /*
// *The appclient script triggers this constructor, so find the persistence
// *JARs in the local directories. During a Java Web Start launch the
// *other constructor is invoked with the already-located JAR URLs.
// */
// this(args, locateLocalPersistenceJARs());
// }
//
// public Main(String[] args, URL[] persistenceJarURLs) {
// /*
// *Temporarily use a cheap memory logger to hold any messages created
// *until we can configure the real logger using the configuration settings.
// */
// BufferedLogger tempLogger = prepareBufferedLogging();
//
// /*
// *Assign the temp logger to _logger so methods that need to log don't
// *need to know if they are doing so before the real logger is set up.
// */
// _logger = tempLogger;
//
// prepareJWSSettings();
//
// try {
// /*
// *Handle any command line arguments intended for the ACC (as opposed to
// *the client itself) and save the returned args intended for the client.
// */
// appArgs = processCommandLine(args);
//
// /*
// *Find the class name to be run if the user has asked to run a .class
// *file as the client.
// */
// String classNameForClassFile = determineClassNameForClassFileLaunch(clientJar, isJWS, mainClass, classFileFromCommandLine);
//
// /*
// *Choose and validate the XML configuration file to use, which depends on the
// *-xml and -configxml command line arguments as well as whether this
// *is a Java Web Start launch or not.
// */
// String xmlPathToUse = chooseConfigFile(xmlPath, accConfigXml, isJWS);
// validateXMLFile(xmlPathToUse);
//
// /*
// *The configuration file just chosen may assign logging settings.
// *Prepare logger using those settings and also flush any records sent to the
// *temp logger to the new, real one.
// */
// _logger = prepareLogging(tempLogger, xmlPathToUse, isJWS);
//
// /*
// *Locate the app client: in a user-specified jar or directory,
// *an implied directory (i.e., user is running a .class file), or the
// *Java Web Start downloaded jar file.
// */
// File appClientJarOrDir = locateAppclientJarOrDir(clientJar, classNameForClassFile, isJWS);
//
// /*
// *Set up the default login config for a Java Web Start launch.
// */
// prepareJWSLoginConfig();
//
// Utility.checkJVMVersion();
// prepareSecurity();
//
// Throwable terminatingException = null;
// AppClientInfo appClientInfo = null;
//
// ClassLoader jcl = null;
//
// Switch.getSwitch().setProviderManager(ProviderManager.getProviderManager());
// /*
// * Set the container type before initializing the ORB so that ORB
// * initializers can correctly identify which container type this is.
// */
// Switch.getSwitch().setContainerType(Switch.APPCLIENT_CONTAINER);
//
// // added for ClientContainer.xml initialization
// // The returned properties will be null if load balancing is on or
// // non-null and containing the initial host and port properties if
// // load balancing is off.
// //
// // Note that setTargetServerProperties must be invoked before the
// // the initial context is instantiated.
// Properties iiopProperties = setTargetServerProperties(xmlPathToUse);
//
// int exitCode = 0; // 0 for success
// prepareURLStreamHandling();
//
// /*
// *The "info" object for the app client collects together common behavior
// *regardless of how the app client was specified (as an archive file,
// *as a directory, or as a .class file) and - if not a .class file -
// *what type of module (an ear or an app client jar).
// *
// *Creating this info object also may extract the ear or jar into
// *a temporary directory, for example for use by persistence unit
// *handling, and may also prepare the persistence unit handling if
// *that is required.
// */
// // log the endpoint address(es) to be used, per Jagadesh's request
// _logger.log(Level.INFO, "acc.endpoints",
// lb_enabled ? System.getProperty(S1ASCtxFactory.IIOP_ENDPOINTS_PROPERTY) :
// iiopProperties.getProperty(ORB_INITIAL_HOST_PROPERTYNAME) + ":" +
// iiopProperties.getProperty(ORB_INITIAL_PORT_PROPERTYNAME));
//
// //ic creation for enabling the ORB intialization with the
// //right host:port values (bug 6397533). The InitialContext must
// //not be instantiated before setTargetServerProperties has run.
// InitialContext ic = AppContainer.initializeNaming(iiopProperties);
//
// appClientInfo = AppClientInfoFactory.buildAppClientInfo(isJWS, _logger, appClientJarOrDir, mainClass, displayName, classFileFromCommandLine, persistenceJarURLs);
//
// ApplicationClientDescriptor appDesc = appClientInfo.getAppClient();
//
// final AppContainer container = createAppContainer(appDesc, guiAuth);
// Cleanup cleanup = prepareShutdownCleanup(container, appClientInfo);
//
// // Set the authenticator which is called back when a
// // protected web resource is requested and authentication data is
// // needed.
// Authenticator.setDefault(new HttpAuthenticator(container));
//
// /*
// *The container needs to use the new classloader to locate any
// *user-specified security callback handler.
// */
// jcl = appClientInfo.getClassLoader();
// String appMainClass = container.preInvoke(ic, jcl);
// /*
// *If the user explicitly indicated the main class to be run, use
// *that value, not the value from the manifest.
// */
// if (mainClass != null) {
// appMainClass = mainClass;
// }
//
// /*
// *The new classloader must be set up as the current context class
// *loader for injection to work. During a Java Web Start launch
// *the class loader in the event dispatcher thread must also be
// *changed.
// */
// Thread.currentThread().setContextClassLoader(jcl);
// if (isJWS) {
// setClassLoaderForEDT(jcl);
// }
//
// /*
// *Load the main class of the app client.
// */
// Class cl = loadMainClientClass(jcl, appMainClass);
//
// //This is required for us to enable interrupt jaxws service
// //creation calls
// System.setProperty("javax.xml.ws.spi.Provider",
// "com.sun.enterprise.webservice.spi.ProviderImpl");
//
// // Inject the application client's injectable resources. This
// // must be done after java:comp/env is initialized but before
// // the application client's main class is invoked. Also make
// // sure the injection mgr will clean up during shutdown.
// InjectionManager injMgr = Switch.getSwitch().getInjectionManager();
// cleanup.setInjectionManager(injMgr, cl, appDesc);
//
// injMgr.injectClass(cl, appDesc);
//
// /*
// Try to locate a script with the same name as the main class,
// but with a file type matching the file types handled by one of the
// scripting engines currently available.
// */
// ScriptingSupport scriptingSupport = new ScriptingSupport(jcl, _logger);
// cleanup.setScriptingSupport(scriptingSupport);
// boolean runMainClass = true;
//
// if(runClient) {
// /*
// Prefer a script instead of the main class if a script is present.
// */
// runMainClass = ! scriptingSupport.startScript(appMainClass, appArgs);
//
// /*
// Do not close the stream yet because the scripting
// engine runs on the Swing event dispatcher thread and
// may not be done reading it yet.
// */
//
// if (runMainClass) {
// /*
// Run the main class if there is no script of the expected
// name or if the attempt to start the script failed.
// */
// String[] applicationArgs = appArgs.toArray(new String[appArgs.size()]);
// Utility.invokeApplicationMain(cl, applicationArgs);
// _logger.info("Application main() returned; GUI elements may be continuing to run");
// }
// }
//
//
// // System.exit is not called if application main returned
// // without error. Registered shutdown hook will perform
// // container cleanup
// } catch (java.lang.reflect.InvocationTargetException ite) {
// Throwable tt = ite.getTargetException();
// _logger.log(Level.WARNING, "acc.app_exception", tt);
// throw new RuntimeException(ite);
// } catch (UserError ue) {
// ue.displayAndExit();
// } catch (Throwable t) {
// if (t instanceof javax.security.auth.login.FailedLoginException){
//
// _logger.info("acc.login_error");
// boolean isGui =
// Boolean.valueOf
// (System.getProperty ("auth.gui","true")).booleanValue();
// String errorMessage =
// localStrings.getString
// ("main.exception.loginError",
// "Incorrect login and/or password");
//
// if (isGui) {
// GUIErrorDialog ged = new GUIErrorDialog (errorMessage);
// ged.show ();
// }
// }
//
// _logger.log(Level.WARNING, "acc.app_exception", t);
//
// if (t instanceof javax.naming.NamingException) {
// _logger.log(Level.WARNING, "acc.naming_exception_received");
// }
// throw new RuntimeException(t);
// } finally {
// shutDownSystemAdapters();
// }
// }
//
// /**
// *Sets the class loader for the event dispatcher thread in case of a
// *Java Web Start launch.
// */
// private void setClassLoaderForEDT(final ClassLoader loader)
// throws InterruptedException, InvocationTargetException {
// SwingUtilities.invokeAndWait(new Runnable() {
// private ClassLoader theCL;
// public void run() {
// Thread.currentThread().setContextClassLoader(loader);
// Toolkit tk = Toolkit.getDefaultToolkit();
// EventQueue eq = tk.getSystemEventQueue();
// eq.push(new EventQueue());
// }
// }
// );
// }
//
// private static URL[] locateLocalPersistenceJARs() {
// try {
// URL[] localPersistenceJARURLs = new URL[LOCAL_LAUNCH_PERSISTENCE_JAR_PATHS.length];
// int slot = 0;
// for (String jarPath : LOCAL_LAUNCH_PERSISTENCE_JAR_PATHS) {
// File jarFile = new File(jarPath);
// localPersistenceJARURLs[slot++] = jarFile.toURI().toURL();
// }
// return localPersistenceJARURLs;
// } catch (MalformedURLException mue) {
// /*
// *This is not a recoverable error, so to minimize changes convert it
// *to an unchecked runtime exception.
// */
// throw new RuntimeException(mue);
// }
// }
//
// /**
// *Chooses behavior of a Java Web Start launch based on property settings.
// *<p>
// *Sets the instance variables isJWS and retainTempFiles as side-effects
// */
// private void prepareJWSSettings() {
// isJWS = Boolean.getBoolean(APPCLIENT_ISJWS_PROPERTYNAME);
// retainTempFiles = Boolean.getBoolean(APPCLIENT_RETAIN_TEMP_FILES_PROPERTYNAME);
// }
//
// /**
// *Set up the security manager and keystores/truststores.
// */
// private void prepareSecurity() {
// /*
// *If -textauth was specified, no need to look for the auth.gui
// *setting since -textauth takes precedence.
// */
// if ( ! useTextAuth) {
// guiAuth = Boolean.valueOf
// (System.getProperty("auth.gui", "true")).booleanValue();
// }
//
// /* security init */
// SecurityManager secMgr = System.getSecurityManager();
// if (!isJWS && secMgr != null &&
// !(J2EESecurityManager.class.equals(secMgr.getClass()))) {
// J2EESecurityManager mgr = new J2EESecurityManager();
// System.setSecurityManager(mgr);
// }
// if (_logger.isLoggable(Level.INFO)) {
// if (secMgr != null) {
// _logger.info("acc.secmgron");
// } else {
// _logger.info("acc.secmgroff");
// }
// }
//
// try{
// /* setup keystores.
// * This is required, for appclients that want to use SSL, especially
// * HttpsURLConnection to perform Https.
// */
// SSLUtils.initStoresAtStartup();
// } catch (Exception e){
// /* This is not necessarily an error. This will arise
// * if the user has not specified keystore/truststore properties.
// * and does not want to use SSL.
// */
// if(_logger.isLoggable(Level.FINER)){
// // show the exact stack trace
// _logger.log(Level.FINER, "main.ssl_keystore_init_failed", e);
// } else{
// // just log it as a warning.
// _logger.log(Level.WARNING, "main.ssl_keystore_init_failed");
// }
// }
//
// try {
// /* setup jsr 196 factory
// * define default factory if it is not already defined
// */
// String defaultFactory = java.security.Security.getProperty
// (AuthConfigFactory.DEFAULT_FACTORY_SECURITY_PROPERTY);
// if (defaultFactory == null) {
// java.security.Security.setProperty
// (AuthConfigFactory.DEFAULT_FACTORY_SECURITY_PROPERTY,
// GFAuthConfigFactory.class.getName());
// }
//
// } catch (Exception e) {
// // XXX put string in catablog
// _logger.log(Level.WARNING, "main.jmac_default_factory");
// }
//
// }
//
// /**
// *Loads the app client's main class given its name and the loader to use.
// *@param jcl the class loader to use for loading the client's main class
// *@param clientMainClassName the name of the client's main class
// *@return the Class object for the client's main class
// *@throws RuntimeException (wraps the ClassNotFoundException) if the main class cannot be loaded
// */
// private Class loadMainClientClass(ClassLoader jcl, String clientMainClassName) throws UserError {
// Class result = null;
// try {
// result = jcl.loadClass(clientMainClassName);
// } catch (java.lang.ClassNotFoundException cnf) {
// String errorMessage = localStrings.getString
// ("appclient.mainclass.not.found", clientMainClassName);
// throw new UserError(errorMessage, cnf);
// }
// _logger.log(Level.INFO, "acc.load_app_class", clientMainClassName);
// return result;
// }
//
// /**
// *Creates the appropriate logger, using any settings in the config file.
// *<p>
// *If any logging information has been buffered into the temporary memory-based
// *logger, flush it to the newly-created log.
// *@param xmlPathToUse config file path
// *@param isJWS indicates if this is a Java Web Start launch
// */
// private Logger prepareLogging(BufferedLogger tempLogger, String xmlPathToUse, boolean isJWS) {
// // make sure the default logger for ACCLogManager is set
// Logger result = LogDomains.getLogger(LogDomains.ACC_LOGGER);
//
// LogManager logMgr = LogManager.getLogManager();
// if (logMgr instanceof ACCLogManager) {
// ((ACCLogManager) logMgr).init(xmlPathToUse);
// }
//
// /*
// *Transfer any records from the temporary logger to the new one.
// */
// tempLogger.pushTo(result);
//
// return result;
// }
//
// /**
// *Processes any command-line arguments, setting up static variables for use
// *later in the processing.
// *<p>
// *As side-effects, these variables may be assigned values:
// *<ul>
// *<le>clientJar
// *<le>displayName
// *<le>mainClass
// *<le>xmlPath
// *<le>accConfigXml
// *<le>guiAuth
// *<le>runClient
// *<le>classFileFromCommandLine
// *<le>System property j2eelogin.name
// *<le>System property j2eelogin.password
// *</ul>
// *@param args the command-line arguments passed to the ACC
// *@return arguments to be passed to the actual client (with ACC arguments removed)
// */
// private Vector<String> processCommandLine(String[] args) throws UserError {
// Vector<String> clientArgs = new Vector();
//
// AtomicInteger i = new AtomicInteger();
// String arg = null;
//
// // Parse command line arguments.
// if(args.length < 1) {
// usage();
// } else {
// while(i.get() < args.length) {
// arg = args[i.getAndIncrement()];
// if(arg.equals(CLIENT)) {
// clientJar = getRequiredCommandOptionValue(args, CLIENT, i, "appclient.clientWithoutValue");
// } else if (arg.equals(NAME)) {
// displayName = getRequiredCommandOptionValue(args, NAME, i, "appclient.nameWithoutValue");
// ensureAtMostOneOfNameAndMainClass();
// } else if(arg.equals(MAIN_CLASS)) {
// mainClass = getRequiredCommandOptionValue(args, MAIN_CLASS, i, "appclient.mainClassWithoutValue");
// ensureAtMostOneOfNameAndMainClass();
// } else if(arg.equals(XML_PATH) ) {
// xmlPath = getRequiredUniqueCommandOptionValue(args, XML_PATH, xmlPath, i, "appclient.xmlWithoutValue");
// } else if(arg.equals(ACC_CONFIG_XML) ) {
// accConfigXml = getRequiredUniqueCommandOptionValue(args, ACC_CONFIG_XML, accConfigXml, i, "appclient.accConfigXmlWithoutValue");
// } else if(arg.equals(TEXT_AUTH)) {
// // Overrides legacy auth.gui setting.
// useTextAuth = true;
// logOption(TEXT_AUTH);
// } else if(arg.equals(NO_APP_INVOKE)) {
// runClient = false;
// logOption(NO_APP_INVOKE);
// } else if(arg.equals(USER)) {
// String userNameValue = getRequiredCommandOptionValue(args, USER, i, "appclient.userWithoutValue");
// System.setProperty(LOGIN_NAME, userNameValue);
// } else if(arg.equals(PASSWORD)) {
// String passwordValue = getRequiredCommandOptionValue(args, PASSWORD, i, "appclient.passwordWithoutValue");
// System.setProperty(LOGIN_PASSWORD, passwordValue);
// } else if (arg.equals(PASSWORD_FILE)) {
// String passwordFileValue = getRequiredCommandOptionValue(args, PASSWORD_FILE, i, "appclient.passwordFileWithoutValue");
// try {
// System.setProperty(LOGIN_PASSWORD,
// loadPasswordFromFile(passwordFileValue));
// } catch(IOException ex) {
// throw new UserError(localStrings.getString("appclient.errorReadingFromPasswordFile", passwordFileValue), ex);
// }
// } else {
// clientArgs.add(arg);
// logArgument(arg);
// }
// }
//
//
// String uname = System.getProperty(LOGIN_NAME);
// String upass = System.getProperty(LOGIN_PASSWORD);
// if( uname != null || upass != null ) {
// UsernamePasswordStore.set(uname, upass);
// }
//
//
//
// /*If this is not a Java Web Start launch, the user may have asked
// *to execute a .class file by omitting the -client argument. In this
// *case the user either specifies the name only of the class to run
// *using -mainclass or omits -mainclass and specifies the path to
// *the .class file as the first command-line argument that would
// *otherwise be passed to the actual client. In this second
// *case, the first argument is removed from the list passed to the client.
// */
// if ((mainClass == null) && (clientJar == null) && ! isJWS) {
// /*
// *Make sure there is at least one argument ready to be passed
// *to the client before trying
// *to use the first one as the class file spec.
// */
// if (clientArgs.size() > 0) {
// classFileFromCommandLine = clientArgs.elementAt(0);
// clientArgs.removeElementAt(0);
// logClassFileArgument(classFileFromCommandLine);
// } else {
// usage();
// }
// }
// }
// logClientArgs(clientArgs);
// return clientArgs;
// }
//
// /**
// *Returns the next unused argument as a String value, so long as there is
// *a next argument and it does not begin with a dash which would indicate
// *the next argument.
// *@param position the mutable current position in the argument array
// *@param errorKey the message key for looking up the correct error if the
// *next argument cannot be used as a value
// */
// private String getRequiredCommandOptionValue(String [] args, String optionName, AtomicInteger position, String errorKey) throws UserError {
// String result = null;
// /*
// *Make sure there is at least one more argument and that it does not
// *start with a dash. Either of those cases means the user omitted
// *the required value.
// */
// if(position.get() < args.length && !args[position.get()].startsWith(DASH)) {
// result = args[position.getAndIncrement()];
// } else {
// throw new UserError(localStrings.getString(errorKey));
// }
// if (_logger.isLoggable(Level.FINE)) {
// _logger.fine(localStrings.getString("appclient.optionValueIs", optionName, result));
// }
// return result;
// }
//
// /**
// *Returns the next unused argument (if present and not prefixed with a dash)
// *as a string value as long as the current value of the argument expected
// *is not already set.
// *@param optionName the name of the option being processed
// *@param currentValue the current value of the argument
// *@param position the mutable current position in the argument array
// *@param errorKey the message key for looking up the correct error if the
// *next argument cannot be used as a value
// *@throws IllegalArgumentException
// */
// private String getRequiredUniqueCommandOptionValue(String [] args, String optionName, String currentValue, AtomicInteger position, String errorKey) throws UserError {
// if (currentValue != null) {
// throw new UserError(localStrings.getString("appclient.duplicateValue", optionName, currentValue));
// }
// return getRequiredCommandOptionValue(args, optionName, position, errorKey);
// }
// /**
// *Makes sure that at most one of the -name and -mainclass arguments
// *appeared on the command line.
// *@throws IllegalArgumentException if both appeared
// */
// private void ensureAtMostOneOfNameAndMainClass() throws UserError {
// if (mainClass != null && displayName != null) {
// throw new UserError(localStrings.getString("appclient.mainclassOrNameNotBoth"));
// }
// }
//
// /**
// *Reports that the specified option name has been processed from the command line.
// *@param optionName the String name of the option
// */
// private void logOption(String optionName) {
// if (_logger.isLoggable(Level.FINE)) {
// _logger.fine(localStrings.getString("appclient.valuelessOptionFound", optionName));
// }
// }
//
// private void logArgument(String arg) {
// if (_logger.isLoggable(Level.FINE)) {
// _logger.fine(localStrings.getString("appclient.argumentValueFound", arg));
// }
// }
//
// private void logClassFileArgument(String classFile) {
// if (_logger.isLoggable(Level.FINE)) {
// _logger.fine(localStrings.getString("appclient.classFileUsed", classFile));
// }
// }
//
// private void logClientArgs(Vector<String> clientArgs) {
// if (_logger.isLoggable(Level.FINE)) {
// _logger.fine(localStrings.getString("appclient.clientArgs", clientArgs.toString()));
// }
// }
//
// /**
// *Decides what class name the user specified IF the user has asked to run
// *a .class file as the client.
// *
// *@param clientJar path to the client jar from the command line processing
// *@param isJWS indicates if the current execution was launched via Java Web Start technology
// *@param mainClass main class name as possibly specified on the command line
// *@param classFileFromCommandLine class file spec from the command line (if present)
// *@return class name to be run if the user has chosen a .class file; null otherwise
// */
// private String determineClassNameForClassFileLaunch(String clientJar, boolean isJWS, String mainClass, String classFileFromCommandLine) throws UserError {
// String result = null;
// boolean isFine = _logger.isLoggable(Level.FINE);
// if(clientJar == null && ! isJWS) {
// // ok, if the first parameter was the appclient class, let's check
// // for its existence.
// String value;
//
// /*
// *To run a .class file, the user omits the -client option and
// *specifies either -mainclass <class-name> or provides
// *the class file path as an argument. In the second case the
// *value will have been captured as classFileFromCommandLine during
// *command line processing.
// */
// if (classFileFromCommandLine != null) {
// value = classFileFromCommandLine;
// if (isFine) {
// _logger.fine(localStrings.getString("appclient.classNameFromArg", classFileFromCommandLine));
// }
// } else {
// value = mainClass;
// if (isFine) {
// _logger.fine(localStrings.getString("appclient.classNameFromMainClass", mainClass));
// }
// }
// if (value.endsWith(".class")) {
// result = value.substring(0, value.length()-".class".length());
// } else {
// result = value;
// }
//
// String path = result.replace('.', File.separatorChar) + ".class";
// File file = new File(path);
// if (!file.isAbsolute()) {
// file = new File(System.getProperty("user.dir"), path);
// }
// /*
// *We have tried to identify the class file to use based on either
// *the -mainclass value (with -client omitted) or the value of the
// *first command-line argument. If we cannot find the class in the user's
// *home directory (and we already know this is not a JWS launch because
// *we are inside the "if") then the user has
// *not entered a valid command or has specified a class we cannot find.
// */
// if (!file.exists()) {
// throw new UserError(localStrings.getString("appclient.cannotFindClassFile", result, file.getAbsolutePath()));
// } else {
// if (isFine) {
// _logger.fine(localStrings.getString("appclient.usingClassFile", file.getAbsolutePath()));
// }
// }
// }
// return result;
// }
//
// /**
// *Selects which config file to use, based on which are specified and whether
// *this is a Java Web Start launch.
// *@param xmlPath config file path as specified on the command line
// *@param accConfigXml fall-back config file containing defaults
// *@param isJWS indicates if this is a Java Web Start launch
// *@return the appropriate config file path
// */
// private String chooseConfigFile(String xmlPath, String accConfigXml, boolean isJWS) {
// String pathToUse = null;
// boolean isFine = _logger.isLoggable(Level.FINE);
//
// if (xmlPath != null) {
// pathToUse = xmlPath;
// if (isFine) {
// _logger.fine(localStrings.getString("appclient.configFrom", XML_PATH, pathToUse));
// }
// } else if (accConfigXml != null ) {
// pathToUse = accConfigXml; //use AS_ACC_CONFIG
// if (isFine) {
// _logger.fine(localStrings.getString("appclient.configFrom", ACC_CONFIG_XML, pathToUse));
// }
// } else if (isJWS) {
// /*
// *Neither -xml nor -configxml were present and this is a Java
// *Web Start invocation. Use
// *the alternate mechanism to create the default config.
// */
// try {
// String jwsACCConfigXml = prepareJWSConfig();
// if (jwsACCConfigXml != null) {
// pathToUse = jwsACCConfigXml;
// if (isFine) {
// _logger.fine(localStrings.getString("appclient.configFromJWSTemplate"));
// }
// }
// } catch (Throwable thr) {
// throw new RuntimeException(localStrings.getString("appclient.errorPrepConfig"), thr);
// }
// }
// return pathToUse;
// }
//
// /**
// *Locates the jar or directory that contains the app client main class.
// *@param clientJar path to the client jar file (if specified)
// *@param className the main class name for the app client
// *@param isJWS indicates if this is a Java Web Start launch
// *
// *@return File object for the jar or directory containing the app client main class
// */
// private File locateAppclientJarOrDir(String clientJar, String className, boolean isJWS) throws ClassNotFoundException, URISyntaxException, UserError {
// File result = null;
// boolean isFine = _logger.isLoggable(Level.FINE);
// /*
// *For Java Web Start launches, locate the jar file implicitly.
// *Otherwise, if the user omitted the clientjar argument (and the
// *code has gotten this far) then the user must have used the
// *first argument as the name of the class in ${user.dir} to run. If
// *the user actually specified the clientjar argument, then use that
// *value as the file spec for the client jar.
// */
// if (isJWS) {
// /*
// *Java Web Start case.
// */
// result = findAppClientFileForJWSLaunch();
// if (isFine) {
// _logger.fine(localStrings.getString("appclient.JWSAppClientFile", result.getAbsolutePath()));
// }
// } else if (clientJar==null) {
// /*
// *First-argument-as-class-name case
// */
// File userDir = new File(System.getProperty("user.dir"));
// File appClientClass = new File(userDir, className);
// result = appClientClass.getParentFile();
// if (isFine) {
// _logger.fine(localStrings.getString("appclient.classFileAppClientFile", result.getAbsolutePath()));
// }
// } else {
// /*
// *Normal case - clientjar argument specified.
// */
// result = new File(clientJar);
// if (isFine) {
// _logger.fine(localStrings.getString("appclient.clientJarAppClientFile", result.getAbsolutePath()));
// }
// /*
// *Make sure the user-specified file - client JAR or .class - exists.
// */
// if ( ! result.exists() ) {
// UserError ue = UserError.formatUserError(
// localStrings.getString("appclient.cannotFindJarFile"),
// result.getAbsolutePath());
// throw ue;
// }
//
// }
// return result;
// }
//
// /**
// *Creates a class loader for the app client, using the jar or directory
// *which contains the main class.
// *@param jarOrDir the File object for the directory or jar file containing the main class
// *@return ClassLoader for use by the app client
// */
// private ClassLoader preparePreliminaryClassLoader(File jarOrDir) throws MalformedURLException {
// ClassLoader result = null;
// URL[] urls = new URL[1];
// urls[0] = jarOrDir.toURI().toURL();
// /*
// *Set the parent of the new class loader to the current loader.
// *The Java Web Start-managed class path is implemented in the
// *current loader, so it must remain on the loader stack.
// */
// ClassLoader currentCL = Thread.currentThread().getContextClassLoader();
// result = new URLClassLoader(urls, currentCL);
//// Thread.currentThread().setContextClassLoader(jcl);
// return result;
// }
//
// private AppContainer createAppContainer(ApplicationClientDescriptor appDesc, boolean guiAuth) {
// AppContainer result = new AppContainer(appDesc, guiAuth);
// if(result == null) {
// _logger.log(Level.WARNING, "acc.no_client_desc",
// (displayName == null) ? mainClass : displayName);
//
// System.exit(1);
// }
// return result;
// }
//
//
// /**
// *Adds a shutdown hook to make sure clean-up work runs at JVM exit.
// */
// private static Cleanup prepareShutdownCleanup(
// AppContainer container, AppClientInfo appClientInfo) {
// // Ensure cleanup is performed, even if
// // application client calls System.exit().
// Cleanup cleanup = new Cleanup();
// Runtime runtime = Runtime.getRuntime();
// runtime.addShutdownHook(cleanup);
// cleanup.setAppContainer(container);
// cleanup.setAppClientInfo(appClientInfo);
// return cleanup;
// }
//
// /**
// *Assigns the URL stream handler factory.
// */
// private static void prepareURLStreamHandling() {
// // Set the HTTPS URL stream handler.
// java.security.AccessController.doPrivileged(new
// java.security.PrivilegedAction() {
// public Object run() {
// URL.setURLStreamHandlerFactory(new
// HttpsURLStreamHandlerFactory());
// return null;
// }
// });
// }
//
// private Properties setTargetServerProperties(String clientXmlLocation)
// throws ConfigException {
//
// boolean isEndpointPropertySpecifiedByUser = false;
// String loadBalancingPolicy = null;
//
// Properties result = new Properties();
//
// StringBuilder completeEndpointList = new StringBuilder();
//
// //FIXME: may need to set the context in switch or generic context. but later
// try {
// if(clientXmlLocation == null || clientXmlLocation.equals("")) {
// clientXmlLocation = DEFAULT_CLIENT_CONTAINER_XML;
// }
//
// // set for com.sun.enterprise.security.jauth.ConfigXMLParser
// System.setProperty(SUNACC_XML_URL, clientXmlLocation);
// _logger.log(Level.INFO, "acc.using_xml_location", clientXmlLocation);
//
// ConfigContext ctx = ConfigFactory.createConfigContext(
// clientXmlLocation, true,
// false, false,
// ClientContainer.class,
// new ACCEntityResolver());
//
// ClientContainer cc = ClientBeansFactory.getClientBean(ctx);
//
// host = cc.getTargetServer(0).getAddress();
// port = cc.getTargetServer(0).getPort();
//
// //check for targetServerEndpoints
// TargetServer[] tServer = cc.getTargetServer();
// String targetServerEndpoints = null;
// for (int i = 0; i < tServer.length; i++) {
// if (targetServerEndpoints == null) {
// targetServerEndpoints = tServer[i].getAddress() +
// ":" + tServer[i].getPort();
// } else {
// targetServerEndpoints = targetServerEndpoints + "," +
// tServer[i].getAddress() +
// ":" + tServer[i].getPort();
// lb_enabled = true;
// }
// }
//
// setSSLData(cc);
//
// //FIXME: what do we do about realm
// ClientCredential cCrd = cc.getClientCredential();
// if(cCrd != null) {
// String uname = null;
// String upass = null;
//
// // if user entered user/password from command line,
// // it take percedence over the xml file. - y.l. 05/15/02
// if (System.getProperty(LOGIN_NAME) == null) {
// _logger.config("using login name from client container xml...");
// //System.setProperty(LOGIN_NAME, cCrd.getUserName());
// uname = cCrd.getUserName();
// }
// if (System.getProperty(LOGIN_PASSWORD) == null) {
// _logger.config("using password from client container xml...");
// //System.setProperty(LOGIN_PASSWORD, cCrd.getPassword());
// upass = cCrd.getPassword();
// }
// if( uname != null || upass != null ) {
// UsernamePasswordStore.set(uname, upass);
// }
// }
// String endpoints_property = null;
// // Check if client requires SSL to be used
// ElementProperty[] props = cc.getElementProperty();
// for ( int i=0; i<props.length; i++ ) {
// if ( props[i].getName().equals("ssl") ) {
// if ( props[i].getValue().equals("required") ) {
// (ORBManager.getCSIv2Props()).put(ORBManager.ORB_SSL_CLIENT_REQUIRED,
// "true");
// }
// }
// if ( props[i].getName().equals(S1ASCtxFactory.LOAD_BALANCING_PROPERTY) ) {
// loadBalancingPolicy = props[i].getValue();
// lb_enabled = true;
// }
// if ( props[i].getName().equals(S1ASCtxFactory.IIOP_ENDPOINTS_PROPERTY) ) {
// isEndpointPropertySpecifiedByUser = true;
// endpoints_property = props[i].getValue().trim();
// lb_enabled = true;
// }
// }
//
// /*
// *If the endpoints property was not set in the XML file's property
// *settings, try to set it from the server's assignment in the JNLP document.
// */
// String jwsEndpointsProperty = System.getProperty(Main.APPCLIENT_IIOP_FAILOVER_ENDPOINTS_PROPERTYNAME);
// if (jwsEndpointsProperty != null) {
// targetServerEndpoints = jwsEndpointsProperty;
// completeEndpointList.append(jwsEndpointsProperty);
// lb_enabled = true;
// _logger.fine("jwsEndpointsProperty = " + jwsEndpointsProperty);
// } else {
// /*
// *Suppress the warning if the endpoints_property was set
// *from the JNLP document, since that is in fact the preferred
// *way to set the endpoints.
// */
// if (isEndpointPropertySpecifiedByUser){
// _logger.warning("acc.targetserver.endpoints.warning");
// }
//
// _logger.fine("targetServerEndpoints = " + targetServerEndpoints +
// "endpoints_property = " +
// endpoints_property);
//
// if (lb_enabled) {
// completeEndpointList.append(targetServerEndpoints.trim());
// if (endpoints_property != null) {
// completeEndpointList.append(",").append(endpoints_property);
// }
// }
// }
// if (lb_enabled) {
// System.setProperty(S1ASCtxFactory.IIOP_ENDPOINTS_PROPERTY, completeEndpointList.toString());
// /*
// * Honor any explicit setting of the load-balancing policy.
// * Otherwise just defer to whatever default the ORB uses.
// */
// if (loadBalancingPolicy != null) {
// System.setProperty(S1ASCtxFactory.LOAD_BALANCING_PROPERTY, loadBalancingPolicy);
// }
// /*
// * For load-balancing the Properties object is not used. Rather,
// * the ORB detects the system property settings. So return a
// * null for the LB case.
// */
// result = null;
// } else {
// /*
// * For the non-load-balancing case, the Properties object must
// * contain the initial host and port settings for the ORB.
// */
// result.setProperty(ORB_INITIAL_HOST_PROPERTYNAME, host);
// result.setProperty(ORB_INITIAL_PORT_PROPERTYNAME, port);
// }
// return result;
// } catch (ConfigException t) {
// _logger.log(Level.WARNING,"acc.acc_xml_file_error" ,
// new Object[] {clientXmlLocation, t.getMessage()});
// _logger.log(Level.FINE, "exception : " + t.toString(), t);
// throw t;
// }
// }
//
// private static void setSSLData(ClientContainer cc) {
// try {
// // Set the SSL related properties for ORB
// TargetServer tServer = cc.getTargetServer(0);
// // TargetServer is required.
// //temp solution to target-server+ change in DTD
// // assuming that multiple servers can be specified but only 1st
// // first one will be used.
// Security security = tServer.getSecurity();
// if (security == null) {
// _logger.fine("No Security input set in ClientContainer.xml");
// // do nothing
// return;
// }
// Ssl ssl = security.getSsl();
// if (ssl == null) {
// _logger.fine("No SSL input set in ClientContainer.xml");
// // do nothing
// return;
//
// }
// //XXX do not use NSS in this release
// //CertDb certDB = security.getCertDb();
// SSLUtils.setAppclientSsl(ssl);
// } catch (Exception ex) {
//
// }
// }
//
//
// private void validateXMLFile(String xmlFullName) throws UserError
// {
// if(xmlFullName == null ||
// xmlFullName.startsWith("-")){ // If no file name is given after -xml argument
// usage();
// }
// try {
// File f = new File(xmlFullName);
// if((f != null) && f.exists() && f.isFile() && f.canRead()){
// return;
// }else{// If given file does not exists
// xmlMessage(xmlFullName);
// }
// } catch (Exception ex) {
// xmlMessage(xmlFullName);
// }
// }
//
// // Shut down system resource adapters. Currently it is
// // only JMS.
// private void shutDownSystemAdapters() {
// try {
// com.sun.enterprise.PoolManager poolmgr =
// Switch.getSwitch().getPoolManager();
// if ( poolmgr != null ) {
// Switch.getSwitch().getPoolManager().killFreeConnectionsInPools();
// }
// } catch( Exception e ) {
// //ignore
// }
//
// try {
// ConnectorRegistry registry = ConnectorRegistry.getInstance();
// ActiveResourceAdapter activeRar = registry.getActiveResourceAdapter
// (ConnectorRuntime.DEFAULT_JMS_ADAPTER);
// if (activeRar != null) {
// activeRar.destroy();
// }
// } catch (Exception e) {
// // Some thing has gone wrong. No problem
// _logger.fine("Exception caught while shutting down system adapter:"+e.getMessage());
// }
// }
//
// private String getUsage() {
// return localStrings.getString(
// "main.usage",
// "appclient [ -client <appjar> | ] [-mainclass |-name ] [-xml ] [-textauth] [-user ] [-password |-passwordfile ] [app-args]");
// }
//
// private void usage() {
// System.out.println(getUsage());
// System.exit(1);
// }
//
// private void xmlMessage(String xmlFullName) throws UserError
// {
// UserError ue = new UserError(localStrings.getString("main.cannot_read_clientContainer_xml", xmlFullName,
// "Client Container xml: " + xmlFullName + " not found or unable to read.\nYou may want to use the -xml option to locate your configuration xml."));
// ue.setUsage(getUsage());
// throw ue;
//
// }
//
// private String loadPasswordFromFile(String fileName)
// throws IOException {
// InputStream inputStream = null;
// try {
// inputStream = new BufferedInputStream(new FileInputStream(fileName));
// Properties props = new Properties();
// props.load(inputStream);
// return props.getProperty("PASSWORD");
// } finally {
// if (inputStream != null) {
// inputStream.close();
// }
// }
// }
//
// private static class Cleanup extends Thread {
// private AppContainer appContainer = null;
// private AppClientInfo appClientInfo = null;
// private boolean cleanedUp = false;
// private InjectionManager injectionMgr = null;
// private ApplicationClientDescriptor appClient = null;
// private Class cls = null;
// private ScriptingSupport scriptingSupport = null;
//
// public Cleanup() {
// }
//
// public void setAppContainer(AppContainer container) {
// appContainer = container;
// }
//
// public void setAppClientInfo(AppClientInfo info) {
// appClientInfo = info;
// }
//
// public void setInjectionManager(InjectionManager injMgr, Class cls, ApplicationClientDescriptor appDesc) {
// injectionMgr = injMgr;
// this.cls = cls;
// appClient = appDesc;
// }
//
// public void setScriptingSupport(ScriptingSupport scriptingSupport) {
// this.scriptingSupport = scriptingSupport;
// }
//
// public void run() {
// _logger.info("Clean-up starting");
// cleanUp();
// }
//
// public void cleanUp() {
// if( !cleanedUp ) {
// try {
// if (scriptingSupport != null) {
// scriptingSupport.close();
// scriptingSupport = null;
// }
// if( appContainer != null ) {
// appContainer.postInvoke();
// }
// if ( appClientInfo != null ) {
// appClientInfo.close();
// }
// if ( injectionMgr != null) {
// // inject the pre-destroy methods before shutting down
// injectionMgr.invokeClassPreDestroy(cls, appClient);
// injectionMgr = null;
// }
// if(appClient != null && appClient.getServiceReferenceDescriptors() != null) {
// // Cleanup client pipe line, if there were service references
// for (Object desc: appClient.getServiceReferenceDescriptors()) {
// ClientPipeCloser.getInstance()
// .cleanupClientPipe((ServiceReferenceDescriptor)desc);
// }
// }
// }
// catch(Throwable t) {
// }
// finally {
// cleanedUp = true;
// }
// } // End if -- cleanup required
// }
// }
// /**
// *Sets up the user-provided or default sun-acc.xml and
// *wss-client-config.xml configurations.
// *@return the file name of the sun-acc.xml file
// */
// private String prepareJWSConfig() throws IOException, FileNotFoundException {
// return prepareJWSDefaultConfig();
// }
//
// /**
// *Creates temporary files for use as default sun-acc.xml and
// *wss-client-config.xml configurations.
// *@return the file name of the temporary sun-acc.xml file
// */
// private String prepareJWSDefaultConfig() throws IOException, FileNotFoundException {
// String result = null;
//
// /*
// *Retrieve the sun-acc and wss-client-config templates.
// */
// String sunACCTemplate = Util.loadResource(this.getClass(), SUN_ACC_DEFAULT_TEMPLATE);
// String wssClientConfigTemplate = Util.loadResource(this.getClass(), WSS_CLIENT_CONFIG_TEMPLATE);
//
// /*
// *Prepare the property names and values for substitution in the templates. Some
// *of the properties are specified in the environment already, so use those
// *as defaults and just add the extra ones.
// */
// Properties tokenValues = new Properties(System.getProperties());
//
// /**
// *Create the wss client config defaults, then write them to a temporary file.
// */
// String wssClientConfig = Util.replaceTokens(wssClientConfigTemplate, tokenValues);
// File wssClientConfigFile = Util.writeTextToTempFile(wssClientConfig, WSS_CLIENT_CONFIG_PREFIX, WSS_CLIENT_CONFIG_SUFFIX, retainTempFiles);
// _logger.fine("Temporary wss-client-config.xml file: " + wssClientConfigFile.getAbsolutePath() + lineSep);
//// pendingLogFine.append("Temporary wss-client-config.xml file: " + wssClientConfigFile.getAbsolutePath() + lineSep);
//
// /*
// *Now that the wss temp file is created, insert its name into the default
// *sun-acc text and write that to another temp file.
// *
// *On Windows, the backslashes in the path will be consumed by the replaceTokens method which will
// *interpret them as quoting the following character. So replace each \ with \\ first. All the slashes
// *have to do with quoting a slash to the Java compiler, then quoting it again to the regex
// *processor.
// */
// String quotedConfigFileSpec = wssClientConfigFile.getAbsolutePath().replaceAll("\\\\", "\\\\\\\\");
// tokenValues.setProperty(SUN_ACC_SECURITY_CONFIG_PROPERTY, quotedConfigFileSpec);
//
// String sunaccContent = Util.replaceTokens(sunACCTemplate, tokenValues);
// File sunaccFile = Util.writeTextToTempFile(sunaccContent, SUN_ACC_PREFIX, SUN_ACC_SUFFIX, retainTempFiles);
// _logger.fine("Temporary sun-acc.xml file: " + sunaccFile.getAbsolutePath());
//// pendingLogFine.append("Temporary sun-acc.xml file: " + sunaccFile.getAbsolutePath());
//
// return sunaccFile.getAbsolutePath();
// }
//
// /**
// *Prepares the JAAS login configuration for a Java Web Start invocation.
// *
// */
// private void prepareJWSLoginConfig() {
// /*
// *If this is a Java Web Start invocation, prepare the user-specified
// *or default login configuration.
// */
// if (isJWS) {
// try {
// prepareJWSDefaultLoginConfig();
// } catch (Throwable thr) {
// throw new RuntimeException(localStrings.getString("appclient.errorPrepJWSLogginConfig"), thr);
// }
// }
// }
//
// /**
// *Extracts the default login.conf file into a temporary file and assigns the
// *java.security.auth.login.config property accordingly.
// */
// private void prepareJWSDefaultLoginConfig() throws IOException, FileNotFoundException {
// /*
// *For a Java Web Start launch, the default login configuration is in a
// *template bundled in the app server's jws jar file. Putting it there
// *allows this method to locate it simply by loading it as a resource, whereas
// *the command-line appclient invocation needs to be able to find the
// *file on-disk somewhere.
// *
// *The contents of the template are loaded and then written to a temp file and
// *that temp file location is assigned to the system property that directs
// *JAAS to the login configuration.
// */
// String configContent = Util.loadResource(this.getClass(), LOGIN_CONF_TEMPLATE);
// File configFile = Util.writeTextToTempFile(configContent, LOGIN_CONF_FILE_PREFIX, LOGIN_CONF_FILE_SUFFIX, retainTempFiles);
// String configFilePath = configFile.getAbsolutePath();
// _logger.fine("Temporary appclientlogin.conf file: " + configFilePath);
// System.setProperty(LOGIN_CONF_PROPERTY_NAME, configFilePath);
// }
//
// /*
// *Returns the jar or directory that contains the specified resource.
// *@param target entry name to look for
// *@return URI object for the jar or directory containing the entry
// */
// private File findContainingJar(String target) throws IllegalArgumentException, URISyntaxException {
// File result = null;
//
// /*
// *Use the current class loader to find the resource.
// */
// URL resourceURL = getClass().getResource(target);
// if (resourceURL != null) {
// URI uri = resourceURL.toURI();
// String scheme = uri.getScheme();
// String ssp = uri.getSchemeSpecificPart();
// if (scheme.equals("jar")) {
// /*
// *The scheme-specific part will look like "file:<file-spec>!/.class"
// *so we need to isolate the scheme and the <file-spec> part.
// *The subscheme (the scheme within the jar) precedes the colon
// *and the file spec appears after it and before the exclamation point.
// */
// int colon = ssp.indexOf(':');
// String subscheme = ssp.substring(0, colon);
// int excl = ssp.indexOf('!');
// String containingJarPath = ssp.substring(colon + 1, excl);
// result = new File(containingJarPath);
// } else if (scheme.equals("file")) {
// /*
// *The URI is already a file, so the part we want is the part
// *up to but not including the resource name we were looking for
// in the first place..
// */
// int resourceNamePosition = ssp.indexOf(target);
// String containingFilePath = ssp.substring(0, resourceNamePosition);
// result = new File(containingFilePath);
// } else {
// throw new IllegalArgumentException(resourceURL.toExternalForm());
// }
// }
// return result;
// }
//
// /**
// *Locate the app client jar file during a Java Web Start launch.
// *@return File object for the client jar file
// */
// private File findAppClientFileForJWSLaunch() throws URISyntaxException {
// /*
// *The JWSACCMain class has already located the downloaded app client
// *jar file and set a property pointing to it.
// */
// File containingJar = new File(System.getProperty("com.sun.aas.downloaded.appclient.jar"));
// _logger.fine("Location of appclient jar file: " + containingJar.getAbsolutePath());
// return containingJar;
// }
//
// /**
// *Creates a memory-based logger for holding log messages that may occur before
// *the user's logging set-up is read.
// *@return a Logger that buffers its log records in memory.
// */
// private BufferedLogger prepareBufferedLogging() {
// /*
// *The buffered logger adds a handler automatically during instantiation.
// */
// BufferedLogger logger = new BufferedLogger();
// return logger;
// }
//
// /**
// *Logger implementation that records its log records in memory. Normally
// *the logger will be flushed to another logger once the second logger has
// *been configured appropriately.
// */
// private class BufferedLogger extends Logger {
//
// /**
// *Creates a new instance of the buffered logger.
// */
// public BufferedLogger() {
// super(null, null);
// addHandler(new BufferedHandler());
// }
//
// /**
// *Flushes any accumulated log messages to the specified target logger.
// *@param target the Logger to receive any buffered messages
// */
// public void pushTo(Logger target) {
// for (Handler handler : getHandlers()) {
// if (handler instanceof BufferedHandler) {
// ((BufferedHandler) handler).pushTo(target);
// }
// }
// }
// }
//
// /**
// *Log handler that accumulates each log record sent to it into memory and
// *flushes those records to another logger when asked. Once this handler is
// *flushed it can no longer be used.
// */
// private class BufferedHandler extends Handler {
//
// /** holds log records until flushed to another logger */
// private Vector<LogRecord> buffer = new Vector();
//
// /**
// *Creates a new instance of the buffered log handler.
// */
// public BufferedHandler() {
// setLevel(Level.ALL);
// setFilter(null);
// setFormatter(new SimpleFormatter());
// }
//
// /**
// *Publishes a log record to the handler.
// *<p>
// *In this handler, the log record is saved in the memory buffer.
// *@paran record the LogRecord to be written
// */
// public synchronized void publish(LogRecord record) {
// if (buffer == null) {
// throw new IllegalStateException("Handler asked to publish log record after pushTo invoked");
// }
// buffer.add(record);
// }
//
// /**
// *Flushes any accumulated log information to the specified target Logger.
// *@param target the Logger to receive buffered messages
// */
// public synchronized void pushTo(Logger target) {
// if (buffer == null) {
// throw new IllegalStateException("Handler asked to push to target more than once");
// }
// for (LogRecord record : buffer) {
// target.log(record);
// }
// close();
// }
//
// /**
// *Closes the handler to further use.
// */
// public void close() throws SecurityException {
// buffer.clear();
// buffer = null;
// }
//
// /**
// *Does nothing because there is no intermediate buffer between the
// *handler and its storage - the storage is itself a memory buffer.
// */
// public void flush() {
// }
// }
}
Other Glassfish examples (source code examples)
Here is a short list of links related to this Glassfish Main.java source code file:
|
The search page
Other Glassfish source code examples at this package level
Click here to learn more about this project
