net.grinder.console.communication.ProcessStatusImplementation Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of grinder-core Show documentation
The Grinder.
The newest version!
// Copyright (C) 2001 - 2012 Philip Aston
// Copyright (C) 2001, 2002 Dirk Feufel
// All rights reserved.
//
// This file is part of The Grinder software distribution. Refer to
// the file LICENSE which is part of The Grinder distribution for
// licensing details. The Grinder distribution is available on the
// Internet at http://grinder.sourceforge.net/
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
// FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
// COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
// HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
// STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
// OF THE POSSIBILITY OF SUCH DAMAGE.

package net.grinder.console.communication;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.Timer;
import java.util.TimerTask;
import java.util.Map.Entry;

import net.grinder.common.processidentity.AgentIdentity;
import net.grinder.common.processidentity.ProcessIdentity;
import net.grinder.common.processidentity.WorkerIdentity;
import net.grinder.common.processidentity.WorkerProcessReport;
import net.grinder.console.communication.ProcessControl.Listener;
import net.grinder.messages.agent.CacheHighWaterMark;
import net.grinder.messages.console.AgentAddress;
import net.grinder.messages.console.AgentAndCacheReport;
import net.grinder.util.AllocateLowestNumber;
import net.grinder.util.ListenerSupport;


/**
 * Handles process status information.
 *
 * @author Dirk Feufel
 * @author Philip Aston
 */
final class ProcessStatusImplementation {

  /**
   * Period at which to update the listeners.
   */
  private static final long UPDATE_PERIOD = 500;

  /**
   * We keep a record of processes for a few seconds after they have been
   * terminated.
   *
   * Every FLUSH_PERIOD, process statuses are checked. Those haven't reported
   * for a while are marked and are discarded if they still haven't been
   * updated by the next FLUSH_PERIOD.
   */
  private static final long FLUSH_PERIOD = 2000;

  /**
   * Map of agent identities to AgentAndWorkers instances. Access is
   * synchronised on the map itself.
   */
  private final Map
    m_agentIdentityToAgentAndWorkers =
      new HashMap();

  /**
   * We have exclusive write access to m_agentNumberMap.We rely on our
   * synchronisation on m_agentIdentityToAgentAndWorkers to avoid
   * race conditions where the timer might otherwise remove an agent
   * immediately after a new report has just arrived.
   */
  private final AllocateLowestNumber m_agentNumberMap;

  private final ListenerSupport m_listeners =
    new ListenerSupport();

  private volatile boolean m_newData = false;

  /**
   * Constructor.
   *
   * @param timer Timer which can be used to schedule housekeeping tasks.
   * @param agentNumberMap Map of {@link AgentIdentity}s to integers.
   */
  public ProcessStatusImplementation(Timer timer,
                                     AllocateLowestNumber agentNumberMap) {
    m_agentNumberMap = agentNumberMap;
    timer.schedule(
      new TimerTask() {
        public void run() { update(); }
      },
      0, UPDATE_PERIOD);

    timer.schedule(
      new TimerTask() {
        public void run() {
          synchronized (m_agentIdentityToAgentAndWorkers) {
            purge(m_agentIdentityToAgentAndWorkers);
          }
        }
      },
      0, FLUSH_PERIOD);
  }

  /**
   * Add a new listener.
   *
   * @param listener A listener.
   */
  public void addListener(Listener listener) {
    m_listeners.add(listener);
  }

  /**
   * How many agents are live?
   *
   * @return The number of agents.
   */
  public int getNumberOfLiveAgents() {
    synchronized (m_agentIdentityToAgentAndWorkers) {
      return m_agentIdentityToAgentAndWorkers.size();
    }
  }

  private void update() {
    if (!m_newData) {
      return;
    }

    m_newData = false;

    final AgentAndWorkers[] processStatuses;

    synchronized (m_agentIdentityToAgentAndWorkers) {
      processStatuses =
        m_agentIdentityToAgentAndWorkers.values().toArray(
          new AgentAndWorkers[m_agentIdentityToAgentAndWorkers.size()]);
    }

    m_listeners.apply(
      new ListenerSupport.Informer() {
        public void inform(Listener l) { l.update(processStatuses); }
      });
  }

  private AgentAndWorkers getAgentAndWorkers(AgentIdentity agentIdentity) {

    synchronized (m_agentIdentityToAgentAndWorkers) {
      final AgentAndWorkers existing =
        m_agentIdentityToAgentAndWorkers.get(agentIdentity);

      if (existing != null) {
        return existing;
      }

      final AgentAndWorkers created = new AgentAndWorkers(agentIdentity);
      m_agentIdentityToAgentAndWorkers.put(agentIdentity, created);

      m_agentNumberMap.add(agentIdentity);

      return created;
    }
  }

  /**
   * Add an agent status report.
   *
   * @param agentProcessStatus Process status.
   */
  public void addAgentStatusReport(AgentAndCacheReport agentProcessStatus) {

    final AgentAndWorkers agentAndWorkers =
      getAgentAndWorkers(agentProcessStatus.getAgentIdentity());

    agentAndWorkers.setAgentProcessStatus(agentProcessStatus);

    m_newData = true;
  }

  /**
   * Add a worker status report.
   *
   * @param workerProcessStatus Process status.
   */
  public void addWorkerStatusReport(WorkerProcessReport workerProcessStatus) {

    final AgentIdentity agentIdentity =
      workerProcessStatus.getWorkerIdentity().getAgentIdentity();

    getAgentAndWorkers(agentIdentity).setWorkerProcessStatus(
      workerProcessStatus);

    m_newData = true;
  }

  /**
   * Callers are responsible for synchronisation.
   */
  private void purge(Map purgableMap) {

    final Set zombies = new HashSet();

    for (Entry entry :
         purgableMap.entrySet()) {

      if (entry.getValue().shouldPurge()) {
        zombies.add(entry.getKey());
      }
    }

    if (zombies.size() > 0) {
      purgableMap.keySet().removeAll(zombies);
      m_newData = true;
    }
  }

  private interface Purgable {
    boolean shouldPurge();
  }

  private abstract class AbstractTimedReference implements Purgable {
    private int m_purgeDelayCount;

    public boolean shouldPurge() {
      // Processes have a short time to report - see the javadoc for
      // FLUSH_PERIOD.
      if (m_purgeDelayCount > 0) {
        return true;
      }

      ++m_purgeDelayCount;

      return false;
    }
  }

  private final class AgentReference extends AbstractTimedReference {
    private final AgentAndCacheReport m_agentProcessReport;

    AgentReference(AgentAndCacheReport agentProcessReport) {
      m_agentProcessReport = agentProcessReport;
    }

    public AgentAndCacheReport getAgentProcessReport() {
      return m_agentProcessReport;
    }

    @Override public boolean shouldPurge() {
      final boolean purge = super.shouldPurge();

      if (purge) {
        // Protected against race with add since the caller holds
        // m_agentIdentityToAgentAndWorkers, and we are about to be
        // removed from m_agentIdentityToAgentAndWorkers.
        m_agentNumberMap.remove(m_agentProcessReport.getAgentIdentity());
      }

      return purge;
    }
  }

  private final class WorkerReference extends AbstractTimedReference {
    private final WorkerProcessReport m_workerProcessReport;

    WorkerReference(WorkerProcessReport workerProcessReport) {
      m_workerProcessReport = workerProcessReport;
    }

    public WorkerProcessReport getWorkerProcessReport() {
      return m_workerProcessReport;
    }
  }

  private static final class UnknownAgentProcessReport
    implements AgentAndCacheReport {

    private final AgentAddress m_address;

    public UnknownAgentProcessReport(AgentAddress address) {
      m_address = address;
    }

    public AgentAddress getProcessAddress() {
      return m_address;
    }

    public AgentIdentity getAgentIdentity() {
      return m_address.getIdentity();
    }

    public State getState() {
      return State.UNKNOWN;
    }

    public CacheHighWaterMark getCacheHighWaterMark() {
      return null;
    }
  }

  /**
   * Implementation of {@link ProcessControl.ProcessReports}.
   *
   * Package scope for unit tests.
   */
  final class AgentAndWorkers
    implements ProcessControl.ProcessReports, Purgable {

    private volatile AgentReference m_agentReportReference;

    // Synchronise on map before accessing.
    private final Map
      m_workerReportReferences = new HashMap();

    AgentAndWorkers(AgentIdentity agentIdentity) {
      setAgentProcessStatus(
        new UnknownAgentProcessReport(new AgentAddress(agentIdentity)));
    }

    void setAgentProcessStatus(AgentAndCacheReport agentProcessStatus) {
      m_agentReportReference = new AgentReference(agentProcessStatus);
    }

    public AgentAndCacheReport getAgentProcessReport() {
      return m_agentReportReference.getAgentProcessReport();
    }

    void setWorkerProcessStatus(WorkerProcessReport workerProcessStatus) {

      synchronized (m_workerReportReferences) {
        m_workerReportReferences.put(workerProcessStatus.getWorkerIdentity(),
                                     new WorkerReference(workerProcessStatus));
      }
    }

    public WorkerProcessReport[] getWorkerProcessReports() {

      synchronized (m_workerReportReferences) {
        final WorkerProcessReport[] result =
          new WorkerProcessReport[m_workerReportReferences.size()];

        int i = 0;

        for (WorkerReference worker : m_workerReportReferences.values()) {
          result[i++] = worker.getWorkerProcessReport();
        }

        return result;
      }
    }

    public boolean shouldPurge() {
      synchronized (m_workerReportReferences) {
        purge(m_workerReportReferences);
      }

      return m_agentReportReference.shouldPurge();
    }
  }
}