* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

*

* Copyright (c) 2000-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.

*/

/*

* @(#)Broker.java  1.287 07/10/07

*/

* The Main class for the broker.

*

* Currently the broker supports a single protocol

* running on a single port, however this class could

* be changed to allow additional protocols/ports at

* a later time

*/

    public static Broker broker = null;

    public boolean allowHA = true;

    public static boolean NO_CLUSTER = false;

    public static boolean NO_HA = false;

    private static boolean DEBUG = false;

    int DEFAULT_CLUSTER_VERSION = ClusterBroadcast.VERSION_410;

    /**

     * message bus - handles communication

     */

    private ClusterBroadcast mbus = null;

    /**

     * Minimum Java version we need to run

     */

    private static final String MIN_JAVA_VERSION = "1.5";

    /**

     * main packet router -> contains routines to run based

     *      on messages 

     */

    private PacketRouter pktrtr = null;

    /**

     * admin packet router -> contains routines to run based

     *      on messages 

     */

    private PacketRouter admin_pktrtr = null;

    /**

     * Transaction list

     */

    private TransactionList tlist = null;

    /**

     * main tcp protocol

     */

    private BrokerResources rb = null;

    private Version version = null;

    private Store store = null;

    private ShareConfigChangeStore shareCCStore = null;

    private boolean clearProps = false;

    private boolean saveProps = false;

    private LicenseBase license = null;

    private String licenseToUse = null;

    private boolean resetTakeoverThenExit = false;

    private Logger logger = null;

    private String adminKeyFile = null;

    /**

     * Hashtable that maps debug aliases to classes. The debug aliases

     * are used to handle parameters to the -debug command line option

     */

    private Hashtable debugAliases = null;

    /**

     * Boolean used to verify that the broker is up and running

     */

    public boolean startupComplete = false;

    /* Shutdown hook */

    public Thread shutdownHook = null;

    /**

     * Used to pass Broker's exit status to NT service wrapper. When

     * we are running as an NT service we do NOT exit the JVM. We pass

     * the status to the service wrapper and let it terminate or restart

     * the VM.

     */

    private int exitStatus = 0;

    private Object exitStatusLock = new Object();

    /**

     * true if we are running as an NT service, else false

     */

    private boolean isNTService = false;

    /**

     * Interval at which to dump diagnostic information. -1 means

     * never dump. 0 means dump at startup and shutdown. Any positive

     * value n means number every n seconds.

     */

    private int diagInterval = -1;

    public boolean silent = false;

    public boolean force = false;

    /**

     * True if -bgnd was specified on the command line

     */

    public boolean background = false;

    public boolean initOnly = false;

    private boolean removeInstance = false;

    private boolean resetStore = false;

    private List<String> embeddedBrokerStartupMessages;

 

    private static BrokerEventListener bkrEvtListener = null;

    private static boolean runningInProcess = false;

    private String haltLogString = "HALT";

    public static boolean isInProcess() {

        return runningInProcess;

    }

  /**

   * Specify a message that will be written to the broker logfile 

   * when the broker starts as an INFO message. This is typically used to log the

   * broker properties configured on an embedded broker, and so is logged immediately

   * after its arguments are logged. However this method can be used for other

   * messages which need to be logged by an embedded broker when it starts.

   *

   * This can be called multiple times to specify

   * multiple messages, each of which will be logged on a separate line.

   *

   * @param embeddedBrokerStartupMessage

   */

  public void addEmbeddedBrokerStartupMessage(String embeddedBrokerStartupMessage) {

    if (embeddedBrokerStartupMessages==null){

      embeddedBrokerStartupMessages=new ArrayList<String>();

    }

    embeddedBrokerStartupMessages.add(embeddedBrokerStartupMessage);

  }

   

    /**

     * Return whether this Broker is allowed to shutdown

     * @param restartRequested whether a subsequent restart would be performed

     * @return whether this Broker is allowed to shutdown

     */

    public static boolean imqcmdCanExit (boolean restartRequested) { 

       if (bkrEvtListener  != null) {

         // delegate the decision to the BrokerEventListener

         BrokerEvent event = null;

         if (restartRequested){

           event = new BrokerEvent (broker, BrokerEvent.Type.RESTART, "Broker is requesting restart"); 

         } else {

           event = new BrokerEvent (broker, BrokerEvent.Type.SHUTDOWN, "Broker is requesting shutdown"); 

         }

         return bkrEvtListener.exitRequested(event, null);

       }

       return !isInProcess();

    }

    public static void setIsInProcess( boolean inprocess)

    {

        runningInProcess = inprocess;

    }

    private static void setBrokerEventListener(BrokerEventListener listen) {

        bkrEvtListener = listen;

    }

    public static Broker getBroker() {

        synchronized (Broker.class) {

             if (broker == null)

                 broker = new Broker();

        }

        return broker;

    }

    public static void destroyBroker(boolean cleanup) {

      boolean triggerFailover=true;

        destroyBroker(cleanup, triggerFailover);

    }

    /**

     * Shutdown the broker but don't exit the JVM

     *

     * @param cleanup Set to true if unused resources should be freed.

     * Should be set to true if the JVM will be left running.

     * May be set to false if we intend to exit the JVM later

     *

     * @param triggerFailover

     */

    public static void destroyBroker(boolean cleanup, boolean triggerFailover) {

       // we want to cleanup all the statics

       if (broker == null) return;

       Object tmp = broker;

       if (Globals.getBrokerStateHandler() != null)

           Globals.getBrokerStateHandler().initiateShutdown(

                  "BrokerProcess", 0, triggerFailover, 0,

                  false, false, true);

       if (cleanup) {

           BrokerMonitor.shutdownMonitor();

           Consumer.clearAllConsumers();

           Destination.clearDestinations();

           DestinationUID.clearCache();

           Producer.clearProducers();

           Session.clearSessions();

           Subscription.clearSubscriptions();

           LockFile.clearLock();

           TLSProtocol.destroy();

        // stop JMX connectors

     Agent agent = Globals.getAgent();

     if (agent != null)  {

         agent.stop();

         agent.unloadMBeans();

     }

      

           PortMapper pm = Globals.getPortMapper();

    

           pm.destroy();

           Globals.cleanup();

           synchronized (Broker.class) {

                 broker = null;

           }

       }

       if (bkrEvtListener  != null) {

             BrokerEvent event = new BrokerEvent (tmp,

                    BrokerEvent.Type.SHUTDOWN, "Broker has been shutdown"); //L10N-XXX

             bkrEvtListener.brokerEvent(event);

             setBrokerEventListener(null);

       }

      

       if (BrokerInstanceImpl.getInstance()!=null){

         BrokerInstanceImpl.getInstance().setShutdown(true);

       }

    }

    private Broker() {

        version = Globals.getVersion();

        rb = Globals.getBrokerResources();

    }

    Properties convertArgs(String args[])

        throws IllegalStateException, EmptyStackException

    {

        // parse arguments

        Properties params = parseArgs(args);

        params.put("BrokerArgs", argsToString(args).trim());

        return params;

    }

    public static void initializePasswdFile()

        throws IOException

    {

        Logger logger = Globals.getLogger();

        BrokerConfig conf = Globals.getConfig();

        BrokerResources rb = Globals.getBrokerResources();

        //

        // INSTANCE BASED AUTHENTICATION AND AUTHORIZATION

        //

        // if (instance's etc directory does not exist) {

        //     if (global access control file exists) {

        //         copy pw & acl files;

        //     } else {

        //         create default pw and acl files;

        //     }

        // }

        // check existence of instance's etc directory

        File localetcdir = new File(Globals.getInstanceEtcDir());

        if (!localetcdir.exists()) {

            localetcdir.mkdir();

            String aclfilename = conf.getProperty(

                AccessController.PROP_ACCESSCONTROL_PREFIX

                + JMQFileAccessControlModel.PROP_FILENAME_SUFFIX,

                JMQFileAccessControlModel.DEFAULT_ACL_FILENAME);

            File gACL = new File(Globals.JMQ_ETC_HOME + File.separator

                    + aclfilename);

            File lACL = new File(localetcdir, aclfilename);

            String pwfilename = conf.getProperty(

                AccessController.PROP_USER_REPOSITORY_PREFIX

                + JMQFileUserRepository.PROP_FILENAME_SUFFIX,

                JMQFileUserRepository.DEFAULT_PW_FILENAME);

            File gPW = new File(Globals.JMQ_ETC_HOME + File.separator

                    + pwfilename);

            File lPW = new File(localetcdir, pwfilename);

            // check if global accesscontrol file exists

            if (gACL.exists()) {

                try {

                    // copy

                    RandomAccessFile graf = new RandomAccessFile(gACL, "r");

                    FileChannel rfc = graf.getChannel();

                    RandomAccessFile oraf = new RandomAccessFile(lACL, "rw");

                    FileChannel wfc = oraf.getChannel();

                    wfc.transferFrom(rfc, 0, graf.length());

                    rfc.close();

                    wfc.close();

                    graf.close();

                    oraf.close();

   

                    graf = new RandomAccessFile(gPW, "r");

                    rfc = graf.getChannel();

                    oraf = new RandomAccessFile(lPW, "rw");

                    wfc = oraf.getChannel();

                    wfc.transferFrom(rfc, 0, graf.length());

                    rfc.close();

                    wfc.close();

                    graf.close();

                    oraf.close();

       

                    Object[] oargs = { pwfilename, aclfilename,

                            Globals.JMQ_ETC_HOME };

                    logger.logToAll(Logger.INFO, rb.I_ACL_PW_FILED_COPIED, oargs);

   

                } catch (IOException ex) {

                    logger.log(Logger.ERROR, "Failed to copy files from the "

                        + Globals.JMQ_ETC_HOME + " directory:", ex);

                    throw ex;

                }

            } else {

                try {

                    // create default

                    FileOutputStream os = new FileOutputStream(lACL);

                    os.write(DEFAULT_ACL_CONTENT.getBytes());

                    os.close();

   

                    os = new FileOutputStream(lPW);

                    os.write(DEFAULT_PW_CONTENT.getBytes());

                    os.close();

                } catch (IOException ex) {

                    logger.log(Logger.ERROR, "Failed to create default files",

                        ex);

                    throw ex;

                }

            }

        }

    }

    int start(boolean inProcess, Properties params, BrokerEventListener bel, boolean initOnly) throws OutOfMemoryError,

      IllegalStateException, IllegalArgumentException {

    setBrokerEventListener(bel);

    int startCode = _start(inProcess, params, initOnly);

    if (bkrEvtListener != null) {

      BrokerEvent event = new BrokerEvent(this, BrokerEvent.Type.READY, "Broker has been started"); // L10N-XXX

      bkrEvtListener.brokerEvent(event);

    }

    return startCode;

  }  

    int _start(boolean inProcess, Properties propsFromCommandLine,

         boolean initOnly)

            throws OutOfMemoryError, IllegalStateException, IllegalArgumentException

    {

      try {

       

        setIsInProcess(inProcess);

        // initialize the Global properties if any arguments are passed in

       

        // read properties (including passwords) from standard input (used when the broker is managed by JMSRA) 

        Properties propsFromStdin = null;

        if (propsFromCommandLine != null &&

            propsFromCommandLine.containsKey(Globals.IMQ + ".readstdin.enabled")){

          propsFromStdin = readPropertiesFromStandardInput();

        }

       

    // Combine any properties specified using command-line parameters with any properties read from standard input

    // The properties loaded from standard input have precedence and so are loaded second

    Properties combinedProps = new Properties();

        if (propsFromCommandLine != null) {

          combinedProps.putAll(propsFromCommandLine);

        }

        if (propsFromStdin != null){

          combinedProps.putAll(propsFromStdin);

        }

       

        Globals.init(combinedProps, clearProps, saveProps);

        if (!removeInstance) {

            BrokerStateHandler.shuttingDown = false;

            BrokerStateHandler.shutdownStarted = false;

        }

        haltLogString = Globals.getBrokerResources().getKString(BrokerResources.W_HALT_BROKER);

        logger = Globals.getLogger();

        String configdir = Globals.getInstanceDir();

        File f = new File(configdir);

        // check permissions on the instance directories

        // (fix for bug 4694589)

        //

        // NOTE: we are unable to log if the directory permissions are

        // incorrect (we cant open the log file)

        //

        if (!f.exists()) { // check parent directory

            while (!f.exists()) { // loop up looking for the parent

                f = f.getParentFile();

                if (f == null) {

                    // now where else to go

                    break;

                }

                if (!f.exists()) {

                    continue;

                }

                if (!f.canWrite() || !f.canRead()) {

            if (!silent) {

           printErr(rb.getString(rb.E_CAN_NOT_WRITE,

                f, Globals.getConfigName()));

            }

                 return (BrokerExitCode.NO_PERMISSION_ON_INSTANCE);

                }

            }

        } else if (!f.canWrite() || !f.canRead()) {

            if (!silent) {

                System.err.println(rb.getString(rb.E_CAN_NOT_WRITE,

                    f, Globals.getConfigName()));

            }

            return (BrokerExitCode.NO_PERMISSION_ON_INSTANCE);

        }

        // DON'T PUT ANY THING THAT HAS THE SIDE EFFECT

        // OF CREATING AN INSTANCE BEFORE THIS CHECK

        if (removeInstance) {

            removeInstance();

        }

        // if a password file is specified, read it

        try {

            parsePassfile();

        } catch (FileNotFoundException ex) {

            logger.log(Logger.FORCE,

                  rb.E_OPTION_VALID_ERROR, ex);

            return (1);

        }

        // Initialize any possible debug settings

        try {

            com.sun.messaging.jmq.util.Debug.setDebug(Globals.getConfig(),

                              Globals.IMQ + ".debug.");

        } catch (Exception e) {

            logger.log(Logger.WARNING, rb.W_BAD_DEBUG_CLASS, e);

        }

        // Initialize any diag settings

        try {

            com.sun.messaging.jmq.util.DiagManager.registerClasses(

                Globals.getConfig(), Globals.IMQ + ".diag.");

        } catch (Exception e) {

            logger.log(Logger.WARNING, rb.W_BAD_DIAG_CLASS, e);

        }

        BrokerConfig conf = Globals.getConfig();

        try {

            checkBrokerConfig(conf);

        } catch (Exception e) {

            logger.logToAll(logger.ERROR, e.getMessage());

            return 1;

        }

        if (!Globals.isJMSRAManagedSpecified() && Globals.isJMSRAManagedBroker()) {

            logger.log(Logger.ERROR, Globals.getBrokerResources().getKString(

                       BrokerResources.E_START_JMSRA_MANAGED_BROKER_NONMANAGED));

            return (1);

        }

        if (Globals.isJMSRAManagedBroker()) {

            try {

            conf.updateBooleanProperty(Globals.JMSRA_MANAGED_PROPERTY, true, true);

            } catch (Exception e) {

            logger.logStack(Logger.ERROR, Globals.getBrokerResources().getKString(

                            BrokerResources.E_SET_BROKER_CONFIG_PROPERTY,

                            Globals.JMSRA_MANAGED_PROPERTY+"=true", e.getMessage()), e);

            return (1);

            }

        }

        // get license before we log anything (logging will trigger

        // the default license to be loaded when the DestinationLogHandler

        // publish to a destination

        BrokerException licenseException = null;

        try {

            license = Globals.getCurrentLicense(licenseToUse);

        } catch (BrokerException ex) {

            // save it and deal with it after we print the banner out

            licenseException = ex;

        }

         String banner =  version.getBanner(false, Version.MINI_COPYRIGHT) +

                  rb.getString(rb.I_JAVA_VERSION) +

                  System.getProperty("java.version") + " " +

                      System.getProperty("java.vendor") + " " +

                      System.getProperty("java.home");

        logger.logToAll(Logger.INFO, rb.NL + banner);

        // Check to see if we have a version mismatch

        if (!version.isProductValid()) {

            // not valid - display an error

            //

            logger.log(Logger.ERROR, BrokerResources.E_INVALID_PRODUCT_VERSION);

            return (1);

        }

        try {

            initializePasswdFile();

        } catch (IOException ex) {

            return (1);

        }

        if (initOnly) {

            logger.log(Logger.INFO, BrokerResources.I_INIT_DONE);

            return 0;

        }

        try {

            AccessController.setSecurityManagerIfneed();

        } catch (Exception e) {

            logger.logStack(Logger.ERROR, e.getMessage(), e);

            return (1);

        }

        if (!MQAuthenticator.authenticateCMDUserIfset()) {

            logger.log(Logger.INFO, BrokerResources.I_SHUTDOWN_BROKER);

            return (1);

        }

        // For printing out VM heap info

        DiagManager.register(new VMDiagnostics());

        // check the license here after banner is printed

        if (licenseException != null) {

            logger.log(Logger.ERROR, licenseException.toString(), licenseException);

            return (1);

        } else if (license.getExpirationDate() != null) {

            Date date = license.getExpirationDate();

            DateFormat fmt = DateFormat.getDateInstance(DateFormat.MEDIUM);

            // print out message for using trial license

      println(rb.getString(rb.M_TRIAL_LICENSE_MESSAGE,

                    fmt.format(date)));

        }

        if (Version.compareVersions(

                System.getProperty("java.specification.version"),

                MIN_JAVA_VERSION, true) < 0) {

            logger.logToAll(Logger.ERROR, rb.E_BAD_JAVA_VERSION,

                System.getProperty("java.specification.version"),

                MIN_JAVA_VERSION);

            return (1);

        }

        String hostname = conf.getProperty(Globals.IMQ + ".hostname");

        // Save value of imq.hostname. This may be null which is OK

        Globals.setHostname(hostname);

        /*

         * In a variety of places we need to know the name of the host

         * the broker is running on, and its IP address. Typically you

         * get this by calling getLocalHost(). But if the broker is running

         * on a multihomed machine, you may want to control which interface

         * (and IP address) the broker uses. Therefore we support the

         * imq.hostname property to let the user configure this.

         */

        if (hostname == null || hostname.equals(Globals.HOSTNAME_ALL)) {

            // No hostname specified. Get local host

            try {

                InetAddress ia = InetAddress.getLocalHost();

                Globals.setBrokerInetAddress(ia);

            } catch (UnknownHostException e) {

                logger.log(Logger.ERROR, rb.E_NO_LOCALHOST, e);

                logger.log(Logger.INFO,  rb.M_BROKER_EXITING);

            return (1);

            }

        } else {

            // Hostname was specified. Use it. We may be on a multihomed

            // machine. Look up the address now so we have its IP

            try {

                InetAddress ia = InetAddress.getByName(hostname);

                Globals.setBrokerInetAddress(ia);

            } catch (UnknownHostException e) {

                logger.log(Logger.ERROR,

                        rb.getString(rb.E_BAD_HOSTNAME_PROP,

                        hostname, Globals.IMQ + ".hostname"),

                        e);

                logger.log(Logger.INFO,rb.M_BROKER_EXITING);

            return (1);

            }

        }

  /*

   * Do the same thing for JMX hostname. On a multihome system,

   * we may want to designate different IP addresses for the broker

   * and for JMX traffic. A new property imq.jmx.hostname is

   * created for this. By default, it will be set to whatever

   * value imq.hostname is set to.

   */

        String jmxHostname = conf.getProperty(Globals.IMQ + ".jmx.hostname");

        // Save value of imq.jmx.hostname. This may be null which is OK

        Globals.setJMXHostname(jmxHostname);

  /*

   * Only check for the case where the JMX hostname is specified. If it

   * is not, it will default to whatever value is configured for

   * the broker hostname (imq.hostname).

   */

        if (jmxHostname != null && !jmxHostname.equals(Globals.HOSTNAME_ALL)) {

            // JMX hostname was specified. Use it. We may be on a multihomed

            // machine. Look up the address now so we have its IP

            try {

                InetAddress ia = InetAddress.getByName(jmxHostname);

                Globals.setJMXInetAddress(ia);

            } catch (UnknownHostException e) {

                logger.log(Logger.ERROR,

                        rb.getString(rb.E_BAD_HOSTNAME_PROP,

                        hostname, Globals.IMQ + ".jmx.hostname"),

                        e);

                logger.log(Logger.INFO,rb.M_BROKER_EXITING);

            return (1);

            }

        }

        try {

            logger.logToAll(Logger.INFO, "   IMQ_HOME=" +

               new File(Globals.JMQ_HOME).getCanonicalPath());

            logger.logToAll(Logger.INFO, "IMQ_VARHOME=" +

               new File(Globals.JMQ_VAR_HOME).getCanonicalPath());

        } catch (IOException e) {

        }

        logger.logToAll(Logger.INFO,

            System.getProperty("os.name") + " " +

            System.getProperty("os.version") + " " +

            System.getProperty("os.arch") + " " +

            Globals.getBrokerHostName() + " " +

            "(" + Runtime.getRuntime().availableProcessors() + " cpu) " +

            System.getProperty("user.name"));

        try {

            // Log ulimit -n values

            Rlimit.Limits limits = Rlimit.get(Rlimit.RLIMIT_NOFILE);

            logger.logToAll(Logger.INFO, rb.getString(rb.I_NOFILES),

                ((limits.current == Rlimit.RLIM_INFINITY) ? "unlimited" :

                                            String.valueOf(limits.current)),

                ((limits.maximum == Rlimit.RLIM_INFINITY) ? "unlimited" :

                                            String.valueOf(limits.maximum)));

        } catch (Exception e) {

            // This is OK. It just means we can't log ulimit values on

            // this platform.

        }

        // Log JVM heap size information

        logger.logToAll(Logger.INFO, rb.getString(rb.I_JAVA_HEAP),

            Long.toString(Runtime.getRuntime().maxMemory() / 1024),

            Long.toString(Runtime.getRuntime().totalMemory() / 1024));

       

        // Start of logging of the various sets of properties that have been supplied in various ways

       

        // log the actual broker command-line arguments

        logger.logToAll(Logger.INFO, rb.getString(rb.I_BROKER_ARGS),

            (propsFromCommandLine == null ? "":propsFromCommandLine.get("BrokerArgs")));