* Licensed to the Apache Software Foundation (ASF) under one or more

* contributor license agreements.  See the NOTICE file distributed with

* this work for additional information regarding copyright ownership.

* The ASF licenses this file to You under the Apache License, Version 2.0

* (the "License"); you may not use this file except in compliance with

* the License.  You may obtain a copy of the License at

*

*      http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

* Manages the lifecycle of an ActiveMQ Broker. A BrokerService consists of a

* number of transport connectors, network connectors and a bunch of properties

* which can be used to configure the broker as its lazily created.

*

*

* @org.apache.xbean.XBean

*/

    protected CountDownLatch slaveStartSignal = new CountDownLatch(1);

    public static final String DEFAULT_PORT = "61616";

    public static final String LOCAL_HOST_NAME;

    public static final String BROKER_VERSION;

    public static final String DEFAULT_BROKER_NAME = "localhost";

    private static final Logger LOG = LoggerFactory.getLogger(BrokerService.class);

    private static final long serialVersionUID = 7353129142305630237L;

    private boolean useJmx = true;

    private boolean enableStatistics = true;

    private boolean persistent = true;

    private boolean populateJMSXUserID;

    private boolean useAuthenticatedPrincipalForJMSXUserID;

    private boolean populateUserNameInMBeans;

    private long mbeanInvocationTimeout = 0;

    private boolean useShutdownHook = true;

    private boolean useLoggingForShutdownErrors;

    private boolean shutdownOnMasterFailure;

    private boolean shutdownOnSlaveFailure;

    private boolean waitForSlave;

    private long waitForSlaveTimeout = 600000L;

    private boolean passiveSlave;

    private String brokerName = DEFAULT_BROKER_NAME;

    private File dataDirectoryFile;

    private File tmpDataDirectory;

    private Broker broker;

    private BrokerView adminView;

    private ManagementContext managementContext;

    private ObjectName brokerObjectName;

    private TaskRunnerFactory taskRunnerFactory;

    private TaskRunnerFactory persistenceTaskRunnerFactory;

    private SystemUsage systemUsage;

    private SystemUsage producerSystemUsage;

    private SystemUsage consumerSystemUsaage;

    private PersistenceAdapter persistenceAdapter;

    private PersistenceAdapterFactory persistenceFactory;

    protected DestinationFactory destinationFactory;

    private MessageAuthorizationPolicy messageAuthorizationPolicy;

    private final List<TransportConnector> transportConnectors = new CopyOnWriteArrayList<TransportConnector>();

    private final List<NetworkConnector> networkConnectors = new CopyOnWriteArrayList<NetworkConnector>();

    private final List<ProxyConnector> proxyConnectors = new CopyOnWriteArrayList<ProxyConnector>();

    private final List<JmsConnector> jmsConnectors = new CopyOnWriteArrayList<JmsConnector>();

    private final List<Service> services = new ArrayList<Service>();

    private MasterConnector masterConnector;

    private String masterConnectorURI;

    private transient Thread shutdownHook;

    private String[] transportConnectorURIs;

    private String[] networkConnectorURIs;

    private JmsConnector[] jmsBridgeConnectors; // these are Jms to Jms bridges

    // to other jms messaging

    // systems

    private boolean deleteAllMessagesOnStartup;

    private boolean advisorySupport = true;

    private URI vmConnectorURI;

    private String defaultSocketURIString;

    private PolicyMap destinationPolicy;

    private final AtomicBoolean started = new AtomicBoolean(false);

    private final AtomicBoolean stopped = new AtomicBoolean(false);

    private final AtomicBoolean stopping = new AtomicBoolean(false);

    private BrokerPlugin[] plugins;

    private boolean keepDurableSubsActive = true;

    private boolean useVirtualTopics = true;

    private boolean useMirroredQueues = false;

    private boolean useTempMirroredQueues = true;

    private BrokerId brokerId;

    private DestinationInterceptor[] destinationInterceptors;

    private ActiveMQDestination[] destinations;

    private PListStore tempDataStore;

    private int persistenceThreadPriority = Thread.MAX_PRIORITY;

    private boolean useLocalHostBrokerName;

    private final CountDownLatch stoppedLatch = new CountDownLatch(1);

    private final CountDownLatch startedLatch = new CountDownLatch(1);

    private boolean supportFailOver;

    private Broker regionBroker;

    private int producerSystemUsagePortion = 60;

    private int consumerSystemUsagePortion = 40;

    private boolean splitSystemUsageForProducersConsumers;

    private boolean monitorConnectionSplits = false;

    private int taskRunnerPriority = Thread.NORM_PRIORITY;

    private boolean dedicatedTaskRunner;

    private boolean cacheTempDestinations = false;// useful for failover

    private int timeBeforePurgeTempDestinations = 5000;

    private final List<Runnable> shutdownHooks = new ArrayList<Runnable>();

    private boolean systemExitOnShutdown;

    private int systemExitOnShutdownExitCode;

    private SslContext sslContext;

    private boolean forceStart = false;

    private IOExceptionHandler ioExceptionHandler;

    private boolean schedulerSupport = false;

    private File schedulerDirectoryFile;

    private Scheduler scheduler;

    private ThreadPoolExecutor executor;

    private boolean slave = true;

    private int schedulePeriodForDestinationPurge= 0;

    private int maxPurgedDestinationsPerSweep = 0;

    private BrokerContext brokerContext;

    private boolean networkConnectorStartAsync = false;

    private boolean allowTempAutoCreationOnSend;

    private int offlineDurableSubscriberTimeout = -1;

    private int offlineDurableSubscriberTaskSchedule = 300000;

    private DestinationFilter virtualConsumerDestinationFilter;

    private final Object persistenceAdapterLock = new Object();

    private Throwable startException = null;

    private boolean startAsync = false;

    private Date startDate;

    static {

        String localHostName = "localhost";

        try {

            localHostName =  InetAddressUtil.getLocalHostName();

        } catch (UnknownHostException e) {

            LOG.error("Failed to resolve localhost");

        }

        LOCAL_HOST_NAME = localHostName;

        InputStream in = null;

        String version = null;

        if ((in = ProtocolConverter.class.getResourceAsStream("/org/apache/activemq/version.txt")) != null) {

            BufferedReader reader = new BufferedReader(new InputStreamReader(in));

            try {

                version = reader.readLine();

            } catch(Exception e) {

            }

        }

        BROKER_VERSION = version;

    }

    @Override

    public String toString() {

        return "BrokerService[" + getBrokerName() + "]";

    }

    private String getBrokerVersion() {

        String version = ActiveMQConnectionMetaData.PROVIDER_VERSION;

        if (version == null) {

            version = BROKER_VERSION;

        }

        return version;

    }

    /**

     * Adds a new transport connector for the given bind address

     *

     * @return the newly created and added transport connector

     * @throws Exception

     */

    public TransportConnector addConnector(String bindAddress) throws Exception {

        return addConnector(new URI(bindAddress));

    }

    /**

     * Adds a new transport connector for the given bind address

     *

     * @return the newly created and added transport connector

     * @throws Exception

     */

    public TransportConnector addConnector(URI bindAddress) throws Exception {

        return addConnector(createTransportConnector(bindAddress));

    }

    /**

     * Adds a new transport connector for the given TransportServer transport

     *

     * @return the newly created and added transport connector

     * @throws Exception

     */

    public TransportConnector addConnector(TransportServer transport) throws Exception {

        return addConnector(new TransportConnector(transport));

    }

    /**

     * Adds a new transport connector

     *

     * @return the transport connector

     * @throws Exception

     */

    public TransportConnector addConnector(TransportConnector connector) throws Exception {

        transportConnectors.add(connector);

        return connector;

    }

    /**

     * Stops and removes a transport connector from the broker.

     *

     * @param connector

     * @return true if the connector has been previously added to the broker

     * @throws Exception

     */

    public boolean removeConnector(TransportConnector connector) throws Exception {

        boolean rc = transportConnectors.remove(connector);

        if (rc) {

            unregisterConnectorMBean(connector);

        }

        return rc;

    }

    /**

     * Adds a new network connector using the given discovery address

     *

     * @return the newly created and added network connector

     * @throws Exception

     */

    public NetworkConnector addNetworkConnector(String discoveryAddress) throws Exception {

        return addNetworkConnector(new URI(discoveryAddress));

    }

    /**

     * Adds a new proxy connector using the given bind address

     *

     * @return the newly created and added network connector

     * @throws Exception

     */

    public ProxyConnector addProxyConnector(String bindAddress) throws Exception {

        return addProxyConnector(new URI(bindAddress));

    }

    /**

     * Adds a new network connector using the given discovery address

     *

     * @return the newly created and added network connector

     * @throws Exception

     */

    public NetworkConnector addNetworkConnector(URI discoveryAddress) throws Exception {

        NetworkConnector connector = new DiscoveryNetworkConnector(discoveryAddress);

        return addNetworkConnector(connector);

    }

    /**

     * Adds a new proxy connector using the given bind address

     *

     * @return the newly created and added network connector

     * @throws Exception

     */

    public ProxyConnector addProxyConnector(URI bindAddress) throws Exception {

        ProxyConnector connector = new ProxyConnector();

        connector.setBind(bindAddress);

        connector.setRemote(new URI("fanout:multicast://default"));

        return addProxyConnector(connector);

    }

    /**

     * Adds a new network connector to connect this broker to a federated

     * network

     */

    public NetworkConnector addNetworkConnector(NetworkConnector connector) throws Exception {

        connector.setBrokerService(this);

        URI uri = getVmConnectorURI();

        Map<String, String> map = new HashMap<String, String>(URISupport.parseParameters(uri));

        map.put("network", "true");

        uri = URISupport.createURIWithQuery(uri, URISupport.createQueryString(map));

        connector.setLocalUri(uri);

        // Set a connection filter so that the connector does not establish loop

        // back connections.

        connector.setConnectionFilter(new ConnectionFilter() {

            public boolean connectTo(URI location) {

                List<TransportConnector> transportConnectors = getTransportConnectors();

                for (Iterator<TransportConnector> iter = transportConnectors.iterator(); iter.hasNext();) {

                    try {

                        TransportConnector tc = iter.next();

                        if (location.equals(tc.getConnectUri())) {

                            return false;

                        }

                    } catch (Throwable e) {

                    }

                }

                return true;

            }

        });

        networkConnectors.add(connector);

        if (isUseJmx()) {

            registerNetworkConnectorMBean(connector);

        }

        return connector;

    }

    /**

     * Removes the given network connector without stopping it. The caller

     * should call {@link NetworkConnector#stop()} to close the connector

     */

    public boolean removeNetworkConnector(NetworkConnector connector) {

        boolean answer = networkConnectors.remove(connector);

        if (answer) {

            unregisterNetworkConnectorMBean(connector);

        }

        return answer;

    }

    public ProxyConnector addProxyConnector(ProxyConnector connector) throws Exception {

        URI uri = getVmConnectorURI();

        connector.setLocalUri(uri);

        proxyConnectors.add(connector);

        if (isUseJmx()) {

            registerProxyConnectorMBean(connector);

        }

        return connector;

    }

    public JmsConnector addJmsConnector(JmsConnector connector) throws Exception {

        connector.setBrokerService(this);

        jmsConnectors.add(connector);

        if (isUseJmx()) {

            registerJmsConnectorMBean(connector);

        }

        return connector;

    }

    public JmsConnector removeJmsConnector(JmsConnector connector) {

        if (jmsConnectors.remove(connector)) {

            return connector;

        }

        return null;

    }

    /**

     * @return Returns the masterConnectorURI.

     */

    public String getMasterConnectorURI() {

        return masterConnectorURI;

    }

    /**

     * @param masterConnectorURI

     *            The masterConnectorURI to set.

     */

    public void setMasterConnectorURI(String masterConnectorURI) {

        this.masterConnectorURI = masterConnectorURI;

    }

    /**

     * @return true if this Broker is a slave to a Master

     */

    public boolean isSlave() {

        return (masterConnector != null && masterConnector.isSlave()) ||

            (masterConnector != null && masterConnector.isStoppedBeforeStart()) ||

            (masterConnector == null && slave);

    }

    public void masterFailed() {

        if (shutdownOnMasterFailure) {

            LOG.error("The Master has failed ... shutting down");

            try {

                stop();

            } catch (Exception e) {

                LOG.error("Failed to stop for master failure", e);

            }

        } else {

            LOG.warn("Master Failed - starting all connectors");

            try {

                startAllConnectors();

                broker.nowMasterBroker();

            } catch (Exception e) {

                LOG.error("Failed to startAllConnectors", e);

            }

        }

    }

    public String getUptime() {

        // compute and log uptime

        if (startDate == null) {

            return "not started";

        }

        long delta = new Date().getTime() - startDate.getTime();

        return TimeUtils.printDuration(delta);

    }

    public boolean isStarted() {

        return started.get();

    }

    /**

     * Forces a start of the broker.

     * By default a BrokerService instance that was

     * previously stopped using BrokerService.stop() cannot be restarted

     * using BrokerService.start().

     * This method enforces a restart.

     * It is not recommended to force a restart of the broker and will not work

     * for most but some very trivial broker configurations.

     * For restarting a broker instance we recommend to first call stop() on

     * the old instance and then recreate a new BrokerService instance.

     *

     * @param force - if true enforces a restart.

     * @throws Exception

     */

    public void start(boolean force) throws Exception {

        forceStart = force;

        stopped.set(false);

        started.set(false);

        start();

    }

    // Service interface

    // -------------------------------------------------------------------------

    protected boolean shouldAutostart() {

        return true;

    }

    /**

     *

     * @throws Exception

     * @org. apache.xbean.InitMethod

     */

    @PostConstruct

    public void autoStart() throws Exception {

        if(shouldAutostart()) {

            start();

        }

    }

    public void start() throws Exception {

        if (stopped.get() || !started.compareAndSet(false, true)) {

            // lets just ignore redundant start() calls

            // as its way too easy to not be completely sure if start() has been

            // called or not with the gazillion of different configuration

            // mechanisms

            // throw new IllegalStateException("Already started.");

            return;

        }

        stopping.set(false);

        startDate = new Date();

        MDC.put("activemq.broker", brokerName);

        try {

            if (systemExitOnShutdown && useShutdownHook) {

                throw new ConfigurationException("'useShutdownHook' property cannot be be used with 'systemExitOnShutdown', please turn it off (useShutdownHook=false)");

            }

            processHelperProperties();

            if (isUseJmx()) {

                // need to remove MDC during starting JMX, as that would otherwise causes leaks, as spawned threads inheirt the MDC and

                // we cannot cleanup clear that during shutdown of the broker.

                MDC.remove("activemq.broker");

                try {

                    startManagementContext();

                } finally {

                    MDC.put("activemq.broker", brokerName);

                }

            }

            // in jvm master slave, lets not publish over existing broker till we get the lock

            final BrokerRegistry brokerRegistry = BrokerRegistry.getInstance();

            if (brokerRegistry.lookup(getBrokerName()) == null) {

                brokerRegistry.bind(getBrokerName(), BrokerService.this);

            }

            startPersistenceAdapter(startAsync);

            startBroker(startAsync);

            brokerRegistry.bind(getBrokerName(), BrokerService.this);

        } catch (Exception e) {

            LOG.error("Failed to start Apache ActiveMQ (" + getBrokerName() + ", " + brokerId + "). Reason: " + e, e);

            try {

                if (!stopped.get()) {

                    stop();

                }

            } catch (Exception ex) {

                LOG.warn("Failed to stop broker after failure in start. This exception will be ignored.", ex);

            }

            throw e;

        } finally {

            MDC.remove("activemq.broker");

        }

    }

    private void startPersistenceAdapter(boolean async) throws Exception {

        if (async) {

            new Thread("Persistence Adapter Starting Thread") {

                @Override

                public void run() {

                    try {

                        doStartPersistenceAdapter();

                    } catch (Throwable e) {

                        startException = e;

                    } finally {

                        synchronized (persistenceAdapterLock) {

                            persistenceAdapterLock.notifyAll();

                        }

                    }

                }

            }.start();

        } else {

            doStartPersistenceAdapter();

        }

    }

    private void doStartPersistenceAdapter() throws Exception {

        getPersistenceAdapter().setUsageManager(getProducerSystemUsage());

        getPersistenceAdapter().setBrokerName(getBrokerName());

        LOG.info("Using Persistence Adapter: " + getPersistenceAdapter());