/*
 * 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.
 */
package org.apache.geode.admin.jmx.internal;

import java.io.File;
import java.io.IOException;
import java.rmi.server.RMIClientSocketFactory;
import java.rmi.server.RMIServerSocketFactory;
import java.text.MessageFormat;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Properties;
import java.util.Set;

import javax.management.InstanceNotFoundException;
import javax.management.MBeanException;
import javax.management.MBeanRegistrationException;
import javax.management.MBeanServer;
import javax.management.MalformedObjectNameException;
import javax.management.Notification;
import javax.management.NotificationFilter;
import javax.management.NotificationListener;
import javax.management.ObjectName;
import javax.management.OperationsException;
import javax.management.ReflectionException;
import javax.management.modelmbean.ModelMBean;
import javax.management.remote.JMXConnectionNotification;
import javax.management.remote.JMXConnectorServer;
import javax.management.remote.JMXConnectorServerFactory;
import javax.management.remote.JMXServiceURL;
import javax.management.remote.rmi.RMIConnectorServer;
import javax.rmi.ssl.SslRMIClientSocketFactory;

import mx4j.tools.adaptor.http.HttpAdaptor;
import org.apache.logging.log4j.Logger;

import org.apache.geode.GemFireException;
import org.apache.geode.GemFireIOException;
import org.apache.geode.LogWriter;
import org.apache.geode.SystemFailure;
import org.apache.geode.admin.AdminDistributedSystem;
import org.apache.geode.admin.AdminException;
import org.apache.geode.admin.jmx.Agent;
import org.apache.geode.admin.jmx.AgentConfig;
import org.apache.geode.admin.jmx.AgentFactory;
import org.apache.geode.distributed.internal.ClusterDistributionManager;
import org.apache.geode.internal.ExitCode;
import org.apache.geode.internal.GemFireVersion;
import org.apache.geode.internal.admin.remote.TailLogResponse;
import org.apache.geode.internal.logging.InternalLogWriter;
import org.apache.geode.internal.logging.LogWriterFactory;
import org.apache.geode.internal.logging.log4j.LogMarker;
import org.apache.geode.internal.statistics.StatisticsConfig;
import org.apache.geode.logging.internal.LoggingSession;
import org.apache.geode.logging.internal.executors.LoggingThread;
import org.apache.geode.logging.internal.log4j.api.LogService;
import org.apache.geode.logging.internal.spi.LogConfig;
import org.apache.geode.logging.internal.spi.LogConfigListener;
import org.apache.geode.logging.internal.spi.LogConfigSupplier;

/**
 * The GemFire JMX Agent provides the ability to administrate one GemFire distributed system via
 * JMX.
 *
 * @since GemFire 3.5
 */
@Deprecated
public class AgentImpl implements org.apache.geode.admin.jmx.Agent,
    org.apache.geode.admin.jmx.internal.ManagedResource, LogConfigSupplier {

  private static final Logger logger = LogService.getLogger();

  /**
   * MX4J HttpAdaptor only supports "basic" as an authentication method. Enabling HttpAdaptor
   * authentication ({@link AgentConfig#HTTP_AUTHENTICATION_ENABLED_NAME}) causes the browser to
   * require a login with username ({@link AgentConfig#HTTP_AUTHENTICATION_USER_NAME}) and password
   * ({@link AgentConfig#HTTP_AUTHENTICATION_PASSWORD_NAME}).
   */
  private static final String MX4J_HTTPADAPTOR_BASIC_AUTHENTICATION = "basic";

  /** JMX Service URL template for JMX/RMI Connector Server */
  private static final String JMX_SERVICE_URL = "service:jmx:rmi://{0}:{1}/jndi/rmi://{2}:{3}{4}";

  /*
   * Set third-party logging configration: MX4J, Jakarta Commons-Logging.
   */
  static {
    checkDebug();
    String commonsLog = System.getProperty("org.apache.commons.logging.log");
    if (commonsLog == null || commonsLog.length() == 0) {
      System.setProperty("org.apache.commons.logging.log",
          "org.apache.commons.logging.impl.SimpleLog");
    }
  }

  /** Enables mx4j tracing if Agent debugging is enabled. */
  private static void checkDebug() {
    try {
      if (Boolean.getBoolean("gfAgentDebug")) {
        mx4j.log.Log.setDefaultPriority(mx4j.log.Logger.TRACE); // .DEBUG
      }
    } catch (VirtualMachineError err) {
      SystemFailure.initiateFailure(err);
      // If this ever returns, rethrow the error. We're poisoned
      // now, so don't let this thread continue.
      throw err;
    } catch (Throwable t) {
      // Whenever you catch Error or Throwable, you must also
      // catch VirtualMachineError (see above). However, there is
      // _still_ a possibility that you are dealing with a cascading
      // error condition, so you also need to check to see if the JVM
      // is still usable:
      SystemFailure.checkFailure();
      /* ignore */
    }
  }

  // -------------------------------------------------------------------------
  // Member variables
  // -------------------------------------------------------------------------

  /** This Agent's log writer */
  private InternalLogWriter logWriter;

  /** This Agent's JMX http adaptor from MX4J */
  private HttpAdaptor httpAdaptor;

  /** This Agent's RMI Connector Server from MX4J */
  private JMXConnectorServer rmiConnector;

  /** The name of the MBean manages this resource */
  private final String mbeanName;

  /** The ObjectName of the MBean that manages this resource */
  private final ObjectName objectName;

  /** The actual ModelMBean that manages this resource */
  private ModelMBean modelMBean;

  /** The configuration for this Agent */
  private final AgentConfigImpl agentConfig;

  /**
   * The <code>AdminDistributedSystem</code> this Agent is currently connected to or
   * <code>null</code>
   */
  private AdminDistributedSystem system;

  /** The agent's configuration file */
  private String propertyFile;

  /**
   * A lock object to guard the Connect and Disconnect calls being made on the agent for connections
   * to the DS
   **/
  private final Object CONN_SYNC = new Object();

  protected MemberInfoWithStatsMBean memberInfoWithStatsMBean;

  private MBeanServer mBeanServer;

  private final LoggingSession loggingSession;
  private final Set<LogConfigListener> logConfigListeners = new HashSet<>();

  // -------------------------------------------------------------------------
  // Constructor(s)
  // -------------------------------------------------------------------------

  /**
   * Constructs a new Agent using the specified configuration.
   *
   * @param agentConfig instance of configuration for Agent
   * @throws org.apache.geode.admin.AdminException if the generated mbeanName does not have the
   *         correct format
   * @throws IllegalArgumentException if agentConfig is null
   */
  public AgentImpl(AgentConfigImpl agentConfig) throws AdminException, IllegalArgumentException {
    loggingSession = LoggingSession.create();

    shutdownHook = new LoggingThread("Shutdown", false, this::disconnectFromSystem);
    addShutdownHook();
    if (agentConfig == null) {
      throw new IllegalArgumentException(
          "AgentConfig must not be null");
    }
    this.agentConfig = agentConfig;
    mbeanName = MBEAN_NAME_PREFIX + MBeanUtils.makeCompliantMBeanNameProperty("Agent");

    try {
      objectName = new ObjectName(mbeanName);
    } catch (MalformedObjectNameException ex) {
      String s = String.format("While creating ObjectName: %s",
          mbeanName);
      throw new AdminException(s, ex);
    }

    propertyFile = this.agentConfig.getPropertyFile().getAbsolutePath();

    // bind address only affects how the Agent VM connects to the system...
    // It should be set only once in the agent lifecycle
    this.agentConfig.setBindAddress(getBindAddress());

    // LOG: create LogWriterAppender and LogWriterLogger
    initLogWriter();

    mBeanServer = MBeanUtils.start();

    MBeanUtils.createMBean(this);

    initializeHelperMbean();
  }

  private void initializeHelperMbean() {
    try {
      memberInfoWithStatsMBean = new MemberInfoWithStatsMBean(this);

      MBeanServer mbs = getMBeanServer();
      mbs.registerMBean(memberInfoWithStatsMBean, memberInfoWithStatsMBean.getObjectName());
      /*
       * We are not re-throwing these exceptions as failure create/register the GemFireTypesWrapper
       * will not stop the Agent from working. But we are logging it as it could be an indication of
       * some problem. Also not creating Localized String for the exception.
       */
    } catch (OperationsException e) {
      logger.info("Failed to initialize MemberInfoWithStatsMBean.", e);
    } catch (MBeanRegistrationException e) {
      logger.info("Failed to initialize MemberInfoWithStatsMBean.", e);
    } catch (AdminException e) {
      logger.info("Failed to initialize MemberInfoWithStatsMBean.", e);
    }
  }

  // -------------------------------------------------------------------------
  // Public operations
  // -------------------------------------------------------------------------

  @Override
  public AgentConfig getConfig() {
    return agentConfig;
  }

  @Override
  public AdminDistributedSystem getDistributedSystem() {
    return system;
  }

  /**
   * Persists the current Agent configuration to its property file.
   *
   * @throws GemFireIOException if unable to persist the configuration to props
   * @see #getPropertyFile
   */
  @Override
  public void saveProperties() {
    throw new GemFireIOException("saveProperties is no longer supported for security reasons");
  }

  /**
   * Starts the jmx agent
   */
  @Override
  public void start() {
    checkDebug();

    agentConfig.validate();

    if (mBeanServer == null) {
      mBeanServer = MBeanUtils.start();
    }

    try {
      startHttpAdaptor();
    } catch (StartupException e) {
      loggingSession.stopSession();
      loggingSession.shutdown();
      throw e;
    }

    try {
      startRMIConnectorServer();
    } catch (StartupException e) {
      stopHttpAdaptor();
      loggingSession.stopSession();
      loggingSession.shutdown();
      throw e;
    }

    try {
      startSnmpAdaptor();
    } catch (StartupException e) {
      stopRMIConnectorServer();
      stopHttpAdaptor();
      loggingSession.stopSession();
      loggingSession.shutdown();
      throw e;
    }

    if (agentConfig.getAutoConnect()) {
      try {
        connectToSystem();
        /*
         * Call Agent.stop() if connectToSystem() fails. This should clean up agent-DS connection &
         * stop all the HTTP/RMI/SNMP adapters started earlier.
         */
      } catch (AdminException ex) {
        logger.error("auto connect failed:  {}",
            ex.getMessage());
        stop();
        throw new StartupException(ex);
      } catch (MalformedObjectNameException ex) {
        String autoConnectFailed = "auto connect failed:  {}";
        logger.error(autoConnectFailed, ex.getMessage());
        stop();
        throw new StartupException(new AdminException(
            String.format("auto connect failed: %s", ex.getMessage()), ex));
      }
    } // getAutoConnect

    logger.info("GemFire JMX Agent is running...");

    if (memberInfoWithStatsMBean == null) {
      initializeHelperMbean();
    }
  }

  /**
   * Deregisters everything this Agent registered and releases the MBeanServer.
   */
  @Override
  public void stop() {
    try {
      logger.info("Stopping JMX agent");

      loggingSession.stopSession();

      // stop the GemFire Distributed System
      stopDistributedSystem();

      // stop all JMX Adaptors and Connectors...
      stopHttpAdaptor();
      stopRMIConnectorServer();
      memberInfoWithStatsMBean = null;
      stopSnmpAdaptor();

      // release the MBeanServer for cleanup...
      MBeanUtils.stop();
      mBeanServer = null;

      // remove the register shutdown hook which disconnects the Agent from the Distributed System
      // upon JVM shutdown
      removeShutdownHook();

      logger.info("Agent has stopped");
    } finally {
      loggingSession.shutdown();
    }

  }

  private void stopDistributedSystem() {
    // disconnect from the distributed system...
    try {
      disconnectFromSystem();
    } catch (Exception e) {
      // disconnectFromSystem already prints any Exceptions
    } catch (VirtualMachineError err) {
      SystemFailure.initiateFailure(err);
      throw err;
    } catch (Error e) {
      // Whenever you catch Error or Throwable, you must also catch VirtualMachineError (see above).
      // However, there is _still_ a possibility that you are dealing with a cascading error
      // condition,
      // so you also need to check to see if the JVM is still usable:
      SystemFailure.checkFailure();
    }
  }

  @Override
  public ObjectName manageDistributedSystem() throws MalformedObjectNameException {
    synchronized (CONN_SYNC) {
      if (isConnected()) {
        return ((AdminDistributedSystemJmxImpl) system).getObjectName();
      }
      return null;
    }
  }

  /**
   * Connects to the DistributedSystem currently described by this Agent's attributes for
   * administration and monitoring.
   *
   * @return the object name of the system that the Agent is now connected to
   */
  @Override
  @edu.umd.cs.findbugs.annotations.SuppressWarnings(
      value = "ST_WRITE_TO_STATIC_FROM_INSTANCE_METHOD",
      justification = "This is only a style warning.")
  public ObjectName connectToSystem() throws AdminException, MalformedObjectNameException {
    synchronized (CONN_SYNC) {
      try {
        if (isConnected()) {
          return ((AdminDistributedSystemJmxImpl) system).getObjectName();
        }

        ClusterDistributionManager.setIsDedicatedAdminVM(true);

        AdminDistributedSystemJmxImpl systemJmx = (AdminDistributedSystemJmxImpl) system;
        if (systemJmx == null) {
          systemJmx = (AdminDistributedSystemJmxImpl) createDistributedSystem(agentConfig);
          system = systemJmx;
        }
        systemJmx.connect(logWriter);

        return new ObjectName(systemJmx.getMBeanName());
      } catch (AdminException e) {
        logger.warn(e.getMessage(), e);
        throw e;
      } catch (RuntimeException e) {
        logger.warn(e.getMessage(), e);
        throw e;
      } catch (VirtualMachineError err) {
        SystemFailure.initiateFailure(err);
        // If this ever returns, rethrow the error. We're poisoned
        // now, so don't let this thread continue.
        throw err;
      } catch (Error e) {
        // Whenever you catch Error or Throwable, you must also
        // catch VirtualMachineError (see above). However, there is
        // _still_ a possibility that you are dealing with a cascading
        // error condition, so you also need to check to see if the JVM
        // is still usable:
        SystemFailure.checkFailure();
        logger.error(e.getMessage(), e);
        throw e;
      }
    }
  }

  /**
   * Disconnects from the current DistributedSystem (if connected to one).
   */
  @Override
  @edu.umd.cs.findbugs.annotations.SuppressWarnings(
      value = "ST_WRITE_TO_STATIC_FROM_INSTANCE_METHOD",
      justification = "This is only a style warning.")
  public void disconnectFromSystem() {
    synchronized (CONN_SYNC) {
      try {
        if (system == null || !system.isConnected()) {
          return;
        }
        system.disconnect();
      } catch (RuntimeException e) {
        logger.warn(e.getMessage(), e);
        throw e;
      } catch (VirtualMachineError err) {
        SystemFailure.initiateFailure(err);
        // If this ever returns, rethrow the error. We're poisoned
        // now, so don't let this thread continue.
        throw err;
      } catch (Error e) {
        // Whenever you catch Error or Throwable, you must also
        // catch VirtualMachineError (see above). However, there is
        // _still_ a possibility that you are dealing with a cascading
        // error condition, so you also need to check to see if the JVM
        // is still usable:
        SystemFailure.checkFailure();
        logger.warn(e.getMessage(), e);
        throw e;
      } finally {
        ClusterDistributionManager.setIsDedicatedAdminVM(false);
      }
    }
  }

  /**
   * Retrieves a displayable snapshot of this Agent's log.
   *
   * @return snapshot of the current log
   */
  public String getLog() {
    File childLogFile = loggingSession.getLogFile().isPresent()
        ? loggingSession.getLogFile().get().getChildLogFile() : null;
    String childTail = tailFile(childLogFile);
    String mainTail = tailFile(new File(agentConfig.getLogFile()));
    if (childTail == null && mainTail == null) {
      return "No log file configured, log messages will be directed to stdout.";
    } else {
      StringBuilder result = new StringBuilder();
      if (mainTail != null) {
        result.append(mainTail);
      }
      if (childTail != null) {
        result
            .append("\n" + "-------------------- tail of child log --------------------" + "\n");
        result.append(childTail);
      }
      return result.toString();
    }
  }

  /**
   * Retrieves display-friendly GemFire version information.
   */
  public String getVersion() {
    return GemFireVersion.asString();
  }

  // -------------------------------------------------------------------------
  // Public attribute accessors/mutators
  // -------------------------------------------------------------------------

  /** Returns true if this Agent is currently connected to a system. */
  @Override
  public boolean isConnected() {
    boolean result = false;
    synchronized (CONN_SYNC) {
      result = ((system != null) && system.isConnected());
    }
    return result;
  }

  /**
   * Gets the agent's property file. This is the file it will use when saving its configuration. It
   * was also used when the agent started to initialize its configuration.
   *
   * @return the agent's property file
   */
  public String getPropertyFile() {
    return propertyFile;
  }

  /**
   * Sets the agent's property file.
   *
   * @param value the name of the file to save the agent properties in.
   * @throws IllegalArgumentException if the specified file is a directory.
   * @throws IllegalArgumentException if the specified file's parent is not an existing directory.
   */
  public void setPropertyFile(String value) {
    File f = (new File(value)).getAbsoluteFile();
    if (f.isDirectory()) {
      throw new IllegalArgumentException(
          String.format("The file %s is a directory.", f));
    }
    File parent = f.getParentFile();
    if (parent != null) {
      if (!parent.isDirectory()) {
        throw new IllegalArgumentException(
            String.format("The directory %s does not exist.", parent));
      }
    }
    propertyFile = f.getPath();
  }

  /**
   * Gets the mcastAddress of the distributed system that this Agent is managing.
   *
   * @return The mcastAddress value
   */
  public String getMcastAddress() {
    return agentConfig.getMcastAddress();
  }

  /**
   * Sets the mcastAddress of the distributed system that this Agent is managing.
   *
   * @param mcastAddress The new mcastAddress value
   */
  public void setMcastAddress(String mcastAddress) {
    agentConfig.setMcastAddress(mcastAddress);
  }

  /**
   * Gets the mcastPort of the distributed system that this Agent is managing.
   *
   * @return The mcastPort value
   */
  public int getMcastPort() {
    return agentConfig.getMcastPort();
  }

  /**
   * Sets the mcastPort of the distributed system that this Agent is managing.
   *
   * @param mcastPort The new mcastPort value
   */
  public void setMcastPort(int mcastPort) {
    agentConfig.setMcastPort(mcastPort);
  }

  /**
   * Gets the locators of the distributed system that this Agent is managing.
   * <p>
   * Format is a comma-delimited list of "host[port]" entries.
   *
   * @return The locators value
   */
  public String getLocators() {
    return agentConfig.getLocators();
  }

  /**
   * Sets the locators of the distributed system that this Agent is managing.
   * <p>
   * Format is a comma-delimited list of "host[port]" entries.
   *
   * @param locators The new locators value
   */
  public void setLocators(String locators) {
    agentConfig.setLocators(locators);
  }

  /**
   * Gets the membership UDP port range in the distributed system that this Agent is monitoring.
   * <p>
   * This range is given as two numbers separated by a minus sign like "min-max"
   *
   * @return membership UDP port range
   */
  public String getMembershipPortRange() {
    return agentConfig.getMembershipPortRange();
  }

  /**
   * Sets the membership UDP port range in the distributed system that this Agent is monitoring.
   * <p>
   * This range is given as two numbers separated by a minus sign like "min-max"
   *
   * @param membershipPortRange membership UDP port range
   */
  public void setMembershipPortRange(String membershipPortRange) {
    agentConfig.setMembershipPortRange(membershipPortRange);
  }

  /**
   * Gets the bindAddress of the distributed system that this Agent is managing.
   *
   * @return The bindAddress value
   */
  public String getBindAddress() {
    return agentConfig.getBindAddress();
  }

  /**
   * Sets the bindAddress of the distributed system that this Agent is managing.
   *
   * @param bindAddress The new bindAddress value
   */
  public void setBindAddress(String bindAddress) {
    agentConfig.setBindAddress(bindAddress);
  }

  /**
   * Retrieves the command that the DistributedSystem will use to perform remote manipulation of
   * config files and log files.
   *
   * @return the remote command for DistributedSystem
   */
  public String getRemoteCommand() {
    return agentConfig.getRemoteCommand();
  }

  /**
   * Sets the command that the DistributedSystem will use to perform remote manipulation of config
   * files and log files.
   *
   * @param remoteCommand the remote command for DistributedSystem
   */
  public void setRemoteCommand(String remoteCommand) {
    agentConfig.setRemoteCommand(remoteCommand);
  }

  /** Returns the system identity for the DistributedSystem */
  public String getSystemId() {
    return agentConfig.getSystemId();
  }

  /** Sets the system identity for the DistributedSystem */
  public void setSystemId(String systemId) {
    agentConfig.setSystemId(systemId);
  }

  /**
   * Gets the logFileSizeLimit in megabytes of this Agent. Zero indicates no limit.
   *
   * @return The logFileSizeLimit value
   */
  public int getLogFileSizeLimit() {
    return agentConfig.getLogFileSizeLimit();
  }

  /**
   * Sets the logFileSizeLimit in megabytes of this Agent. Zero indicates no limit.
   *
   * @param logFileSizeLimit The new logFileSizeLimit value
   */
  public void setLogFileSizeLimit(int logFileSizeLimit) {
    agentConfig.setLogFileSizeLimit(logFileSizeLimit);
    logConfigChanged();
  }

  /**
   * Gets the logDiskSpaceLimit in megabytes of this Agent. Zero indicates no limit.
   *
   * @return The logDiskSpaceLimit value
   */
  public int getLogDiskSpaceLimit() {
    return agentConfig.getLogDiskSpaceLimit();
  }

  /**
   * Sets the logDiskSpaceLimit in megabytes of this Agent. Zero indicates no limit.
   *
   * @param logDiskSpaceLimit The new logDiskSpaceLimit value
   */
  public void setLogDiskSpaceLimit(int logDiskSpaceLimit) {
    agentConfig.setLogDiskSpaceLimit(logDiskSpaceLimit);
    logConfigChanged();
  }

  /**
   * Gets the logFile name for this Agent to log to.
   *
   * @return The logFile value
   */
  public String getLogFile() {
    return agentConfig.getLogFile();
  }

  /**
   * Sets the logFile name for this Agent to log to.
   *
   * @param logFile The new logFile value
   */
  public void setLogFile(String logFile) {
    agentConfig.setLogFile(logFile);
    logConfigChanged();
  }

  /**
   * Gets the logLevel of this Agent.
   *
   * @return The logLevel value
   */
  public String getLogLevel() {
    return agentConfig.getLogLevel();
  }

  /**
   * Sets the logLevel of this Agent.
   *
   * @param logLevel The new logLevel value
   */
  public void setLogLevel(String logLevel) {
    agentConfig.setLogLevel(logLevel);
    logConfigChanged();
  }

  /** Returns true if the Agent is set to auto connect to a system. */
  public boolean getAutoConnect() {
    return agentConfig.getAutoConnect();
  }

  /** Returns true if the Agent is set to auto connect to a system. */
  public boolean isAutoConnect() {
    return agentConfig.getAutoConnect();
  }

  /** Sets or unsets the option to auto connect to a system. */
  public void setAutoConnect(boolean v) {
    agentConfig.setAutoConnect(v);
  }

  /**
   * Returns the address (URL) on which the RMI connector server runs or <code>null</code> if the
   * RMI connector server has not been started. This method is used primarily for testing purposes.
   *
   * @see JMXConnectorServer#getAddress()
   */
  public JMXServiceURL getRMIAddress() {
    if (rmiConnector != null) {
      return rmiConnector.getAddress();

    } else {
      return null;
    }
  }

  /**
   * Gets the configuration for this Agent.
   *
   * @return the configuration for this Agent
   */
  protected AgentConfig getAgentConfig() {
    return agentConfig;
  }

  // -------------------------------------------------------------------------
  // Internal implementation methods
  // -------------------------------------------------------------------------

  /** Returns the tail of the system log specified by <code>File</code>. */
  private String tailFile(File f) {
    try {
      return TailLogResponse.tailSystemLog(f);
    } catch (IOException ex) {
      return String.format("Could not tail %s because: %s",
          f, ex);
    }
  }

  /**
   * Returns the active MBeanServer which has any GemFire MBeans registered.
   *
   * @return the GemFire mbeanServer
   */
  @Override
  public MBeanServer getMBeanServer() {
    return mBeanServer;
  }

  /**
   * Gets the current instance of LogWriter for logging
   *
   * @return the logWriter
   */
  @Override
  public LogWriter getLogWriter() {
    return logWriter;
  }

  private final Thread shutdownHook;

  /**
   * Adds a ShutdownHook to the Agent for cleaning up any resources
   */
  private void addShutdownHook() {
    if (!Boolean.getBoolean(
        org.apache.geode.distributed.internal.InternalDistributedSystem.DISABLE_SHUTDOWN_HOOK_PROPERTY)) {
      Runtime.getRuntime().addShutdownHook(shutdownHook);
    }
  }

  private void removeShutdownHook() {
    if (!Boolean.getBoolean(
        org.apache.geode.distributed.internal.InternalDistributedSystem.DISABLE_SHUTDOWN_HOOK_PROPERTY)) {
      Runtime.getRuntime().removeShutdownHook(shutdownHook);
    }
  }

  /**
   * Creates a LogWriterI18n for this Agent to use in logging.
   */
  @edu.umd.cs.findbugs.annotations.SuppressWarnings(value = "RV_RETURN_VALUE_IGNORED_BAD_PRACTICE",
      justification = "Return value for file delete is not important here.")
  private void initLogWriter() throws org.apache.geode.admin.AdminException {
    loggingSession.createSession(this);

    final LogConfig logConfig = agentConfig.createLogConfig();

    // LOG: create logWriterAppender here
    loggingSession.startSession();

    // LOG: look in AgentConfigImpl for existing LogWriter to use
    InternalLogWriter existingLogWriter = agentConfig.getInternalLogWriter();
    if (existingLogWriter != null) {
      logWriter = existingLogWriter;
    } else {
      // LOG: create LogWriterLogger
      logWriter = LogWriterFactory.createLogWriterLogger(logConfig, false);
      // Set this log writer in AgentConfigImpl
      agentConfig.setInternalLogWriter(logWriter);
    }

    // LOG: create logWriter here
    logWriter = LogWriterFactory.createLogWriterLogger(logConfig, false);

    // Set this log writer in AgentConfig
    agentConfig.setInternalLogWriter(logWriter);

    // LOG:CONFIG: changed next three statements from config to info
    logger.info(LogMarker.CONFIG_MARKER,
        String.format("Agent config property file name: %s",
            AgentConfigImpl.retrievePropertyFile()));
    logger.info(LogMarker.CONFIG_MARKER, agentConfig.getPropertyFileDescription());
    logger.info(LogMarker.CONFIG_MARKER, agentConfig.toPropertiesAsString());
  }

  /**
   * Stops the HttpAdaptor and its XsltProcessor. Unregisters the associated MBeans.
   */
  private void stopHttpAdaptor() {
    if (!agentConfig.isHttpEnabled()) {
      return;
    }

    // stop the adaptor...
    try {
      httpAdaptor.stop();
    } catch (Exception e) {
      logger.warn(e.getMessage(), e);
    }

    try {
      MBeanUtils.unregisterMBean(getHttpAdaptorName());
      MBeanUtils.unregisterMBean(getXsltProcessorName());
    } catch (MalformedObjectNameException e) {
      logger.warn(e.getMessage(), e);
    }
  }

  /** Stops the RMIConnectorServer and unregisters its MBean. */
  private void stopRMIConnectorServer() {
    if (!agentConfig.isRmiEnabled()) {
      return;
    }

    // stop the RMI Connector server...
    try {
      rmiConnector.stop();
    } catch (Exception e) {
      logger.warn(e.getMessage(), e);
    }

    try {
      ObjectName rmiRegistryNamingName = getRMIRegistryNamingName();
      if (agentConfig.isRmiRegistryEnabled()
          && mBeanServer.isRegistered(rmiRegistryNamingName)) {
        String[] empty = new String[0];
        mBeanServer.invoke(rmiRegistryNamingName, "stop", empty, empty);
        MBeanUtils.unregisterMBean(rmiRegistryNamingName);
      }
    } catch (MalformedObjectNameException e) {
      logger.warn(e.getMessage(), e);
    } catch (InstanceNotFoundException e) {
      logger.warn(e.getMessage(), e);
    } catch (ReflectionException e) {
      logger.warn(e.getMessage(), e);
    } catch (MBeanException e) {
      logger.warn(e.getMessage(), e);
    }

    try {
      ObjectName rmiConnectorServerName = getRMIConnectorServerName();
      if (mBeanServer.isRegistered(rmiConnectorServerName)) {
        MBeanUtils.unregisterMBean(rmiConnectorServerName);
      }
    } catch (MalformedObjectNameException e) {
      logger.warn(e.getMessage(), e);
    }
  }

  /** Stops the SnmpAdaptor and unregisters its MBean. */
  private void stopSnmpAdaptor() {
    if (!agentConfig.isSnmpEnabled()) {
      return;
    }

    // stop the SnmpAdaptor...
    try {
      getMBeanServer().invoke(getSnmpAdaptorName(), "unbind", new Object[0], new String[0]);
    } catch (Exception e) {
      logger.warn(e.getMessage(), e);
    }

    try {
      MBeanUtils.unregisterMBean(getSnmpAdaptorName());
    } catch (MalformedObjectNameException e) {
      logger.warn(e.getMessage(), e);
    }
  }

  /** Returns the JMX ObjectName for the RMI registry Naming MBean. */
  private ObjectName getRMIRegistryNamingName()
      throws javax.management.MalformedObjectNameException {
    return ObjectName.getInstance("naming:type=rmiregistry");
  }

  /** Returns the JMX ObjectName for the HttpAdaptor. */
  private ObjectName getHttpAdaptorName() throws javax.management.MalformedObjectNameException {
    return new ObjectName("Server:name=HttpAdaptor");
  }

  /** Returns the JMX ObjectName for the RMIConnectorServer. */
  private ObjectName getRMIConnectorServerName()
      throws javax.management.MalformedObjectNameException {
    return new ObjectName("connectors:protocol=rmi");
  }

  /** Returns the JMX ObjectName for the SnmpAdaptor. */
  private ObjectName getSnmpAdaptorName() throws javax.management.MalformedObjectNameException {
    return new ObjectName("Adaptors:protocol=SNMP");
  }

  /** Returns the JMX ObjectName for the HttpAdaptor's XsltProcessor. */
  private ObjectName getXsltProcessorName() throws javax.management.MalformedObjectNameException {
    return new ObjectName("Server:name=XSLTProcessor");
  }

  // -------------------------------------------------------------------------
  // Factory method for creating DistributedSystem
  // -------------------------------------------------------------------------

  /**
