/FileExtraction/Java_unseen/dlitz_resin/modules/kernel/src/com/caucho/lifecycle/Lifecycle.java
/*
 * Copyright (c) 1998-2011 Caucho Technology -- all rights reserved
 *
 * This file is part of Resin(R) Open Source
 *
 * Each copy or derived work must preserve the copyright notice and this
 * notice unmodified.
 *
 * Resin Open Source is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Resin Open Source is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, or any warranty
 * of NON-INFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Resin Open Source; if not, write to the
 *
 *   Free Software Foundation, Inc.
 *   59 Temple Place, Suite 330
 *   Boston, MA 02111-1307  USA
 *
 * @author Scott Ferguson
 */

package com.caucho.lifecycle;

import static com.caucho.lifecycle.LifecycleState.ACTIVE;
import static com.caucho.lifecycle.LifecycleState.DESTROYED;
import static com.caucho.lifecycle.LifecycleState.DESTROYING;
import static com.caucho.lifecycle.LifecycleState.FAILED;
import static com.caucho.lifecycle.LifecycleState.INIT;
import static com.caucho.lifecycle.LifecycleState.INITIALIZING;
import static com.caucho.lifecycle.LifecycleState.STARTING;
import static com.caucho.lifecycle.LifecycleState.STOPPED;
import static com.caucho.lifecycle.LifecycleState.STOPPED_IDLE;
import static com.caucho.lifecycle.LifecycleState.STOPPING;

import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.concurrent.atomic.AtomicReference;
import java.util.logging.Level;
import java.util.logging.Logger;

import com.caucho.util.Alarm;

/**
 * Lifecycle class.
 */
public final class Lifecycle {
  private final Logger _log;
  private String _name;
  
  private Level _level = Level.FINE;
  private Level _lowLevel = Level.FINER;
  
  private final AtomicReference<LifecycleState> _state
    = new AtomicReference<LifecycleState>(LifecycleState.NEW);

  private long _activeCount;
  private long _failCount;

  private long _lastFailTime;
  private long _lastChangeTime;

  private ArrayList<WeakReference<LifecycleListener>> _listeners;

  /**
   * Creates an anonymous lifecycle.
   */
  public Lifecycle()
  {
    _log = null;
  }

  /**
   * Creates an lifecycle with logger and name.
   */
  public Lifecycle(Logger log)
  {
    _log = log;
  }

  /**
   * Creates an lifecycle with logger and name.
   */
  public Lifecycle(Logger log, String name)
  {
    _log = log;
    _name = name;
  }

  /**
   * Creates an lifecycle with logger,  a name, and a level.
   */
  public Lifecycle(Logger log, String name, Level level)
  {
    _log = log;
    _name = name;
    
    setLevel(level);
  }

  /**
   * Gets the lifecycle name.
   */
  public String getName()
  {
    return _name;
  }

  /**
   * Sets the lifecycle name, and the level to Level.INFO.
   */
  public void setName(String name)
  {
    _name = name;
  }

  /**
   * Gets the lifecycle logging level.
   */
  public Level getLevel()
  {
    return _level;
  }

  /**
   * Sets the lifecycle logging level.
   */
  public void setLevel(Level level)
  {
    _level = level;

    if (level.intValue() < _lowLevel.intValue())
      _lowLevel = level;
  }

  public final LifecycleState getState()
  {
    return _state.get();
  }
  
  /**
   * Returns the current state.
   */
  public int getStateOrdinal()
  {
    return _state.get().ordinal();
  }

  /**
   * Returns the state name for the passed state.
   */
  /*
  public static String getStateName(int state)
  {
    switch (state) {
      case IS_NEW:
        return "new";
      case IS_INITIALIZING:
        return "initializing";
      case IS_INIT:
        return "init";
      case IS_STARTING:
        return "starting";
      case IS_ACTIVE:
        return "active";
      case IS_FAILED:
        return "failed";
      case IS_STOPPING:
        return "stopping";
      case IS_STOPPED:
        return "stopped";
      case IS_DESTROYING:
        return "destroying";
      case IS_DESTROYED:
        return "destroyed";
      default:
        return "unknown";
    }
  }
  */

  /**
   * Returns the current state name.
   */
  public String getStateName()
  {
    return getState().toString();
  }

  /**
   * Returns the last lifecycle change time.
   */
  public long getLastChangeTime()
  {
    return _lastChangeTime;
  }

  /**
   * Returns the last failure time.
   */
  public long getLastFailTime()
  {
    return _lastFailTime;
  }

  /**
   * Returns the number of times the lifecycle has switched to active.
   */
  public long getActiveCount()
  {
    return _activeCount;
  }

  /**
   * Returns the number of times the lifecycle has switched to failing.
   */
  public long getFailCount()
  {
    return _failCount;
  }

  /**
   * Returns true for the initializing state.
   */
  public boolean isInitializing()
  {
    return getState().isInitializing();
  }

  /**
   * Returns true for the init state.
   */
  public boolean isInit()
  {
    return getState().isInit();
  }

  /**
   * Returns true for the init state.
   */
  public boolean isBeforeInit()
  {
    return getState().isBeforeInit();
  }

  /**
   * True for any state after initialization.
   */
  public boolean isAfterInit()
  {
    return getState().isAfterInit();
  }

  /**
   * True for an idle state, where any request would transition to an
   * active state.
   */
  public boolean isIdle()
  {
    return getState().isIdle();
  }

  /**
   * Returns true if the service is starting.
   */
  public boolean isStarting()
  {
    return getState().isStarting();
  }

  /**
   * Returns true if the service is starting.
   */
  /*
  public boolean isAfterStarting()
  {
    return getState().isAfterStarting();
  }
  */

  /**
   * Returns true for the warmup state.
   */
  public boolean isWarmup()
  {
    return getState().isWarmup();
  }

  /**
   * Returns true for the initializing state.
   */
  public boolean isBeforeActive()
  {
    return getState().isBeforeActive();
  }

  /**
   * Returns true for the closing states
   */
  /*
  public boolean isAfterActive()
  {
    return getState().isAfterActive();
  }
  */

  /**
   * Wait for a period of time until the service starts.
   */
  public boolean waitForActive(long timeout)
  {
    LifecycleState state = getState();

    if (state.isActive())
      return true;
    else if (state.isAfterActive())
      return false;
    
    // server/1d2j
    long waitEnd = Alarm.getCurrentTimeActual() + timeout;

    synchronized (this) {
      while ((state = _state.get()).isBeforeActive()
             && Alarm.getCurrentTimeActual() < waitEnd) {
        if (state.isActive())
          return true;
        else if (state.isAfterActive())
          return false;

        try {
          long delta = waitEnd - Alarm.getCurrentTimeActual();
          
          if (delta > 0) {
            wait(delta);
          }
        } catch (InterruptedException e) {
        }
      }
    }
    
    return _state.get().isActive();
  }

  /**
   * Returns true for the active state.
   */
  public boolean isActive()
  {
    return getState().isActive();
  }

  /**
   * Returns true for the a runnable state, including warmup
   */
  public boolean isRunnable()
  {
    return getState().isRunnable();
    /*
    int state = _state.get();
    
    return IS_WARMUP <= state && state <= IS_ACTIVE;
    */
  }

  /**
   * Returns true for the closing states
   */
  public boolean isAfterStopping()
  {
    return getState().isAfterStopping();
  }

  /**
   * Returns true for the failed state.
   */
  public boolean isError()
  {
    return getState().isError();
  }

  /**
   * Returns true for the failed state.
   */
  public boolean isFailed()
  {
    return getState().isError();
  }

  /**
   * True if a stop for a restart would be allowed.
   */
  public boolean isAllowStopFromRestart()
  {
    return getState().isAllowStopFromRestart();
  }

  /**
   * Returns true if the state is stopping.
   */
  public boolean isStopping()
  {
    return getState().isStopping();
  }

  /**
   * Returns true if the state is stopping.
   */
  public boolean isStopped()
  {
    return getState().isStopped();
  }

  /**
   * Returns true if the state is closed
   */
  public boolean isDestroying()
  {
    return getState().isDestroying();
  }

  /**
   * Returns true if the state is closed
   */
  public boolean isDestroyed()
  {
    return getState().isDestroyed();
  }
  
  /**
   * Changes to the initializing state.
   *
   * @return true if the transition is allowed
   */
  public boolean toInitializing()
  {
    return toNextState(INITIALIZING);
  }

  /**
    * Changes to the init state.
    *
    * @return true if the transition is allowed
    */
   public boolean toInit()
   {
     return toNextState(INIT);
   }
  
  /**
    * Changes to the init from the stopped state.
    *
    * @return true if the transition is allowed
    */
   public boolean toPostInit()
   {
     if (_state.compareAndSet(STOPPED, INIT)) {
       _lastChangeTime = Alarm.getCurrentTime();

       notifyListeners(STOPPED, INIT);

       return true;
     }
     else
       return _state.get().isInit();
   }

  /**
   * Changes to the starting state.
   *
   * @return true if the transition is allowed
   */
  public boolean toStarting()
  {
    LifecycleState state;
    
    do {
      state = _state.get();

      if (state.isAfterStarting() && ! state.isStopped())
        return false;
    } while (! _state.compareAndSet(state, STARTING));

    _lastChangeTime = Alarm.getCurrentTime();

    if (_log != null && _log.isLoggable(_level) && _log.isLoggable(Level.FINE))
      _log.fine(_name + " starting");

    notifyListeners(state, STARTING);

    return true;
  }
  
  /**
   * Changes to the active state.
   *
   * @return true if the transition is allowed
   */
  public boolean toActive()
  {
    LifecycleState state;
    
    do {
      state = _state.get();

      if (state.isAfterActive() && ! state.isStopped())
        return false;
    } while (! _state.compareAndSet(state, ACTIVE));

    _lastChangeTime = Alarm.getCurrentTime();

    if (_log != null && _log.isLoggable(_level))
      _log.log(_level, _name + " active");

    notifyListeners(state, ACTIVE);

    synchronized (this) {
      notifyAll();
    }

    return true;
  }
  
  /**
   * Changes to the error state.
   *
   * @return true if the transition is allowed
   */
  public boolean toError()
  {
    return toFail();
  }
  
  /**
   * Changes to the failed state.
   *
   * @return true if the transition is allowed
   */
  public boolean toFail()
  {
    LifecycleState state;

    do {
      state = _state.get();
      
      if (state.isAfterDestroying())
        return false;
    } while (! _state.compareAndSet(state, FAILED));

    _lastChangeTime = Alarm.getCurrentTime();

    if (_log != null && _log.isLoggable(_level))
      _log.log(_level, _name + " fail");

    notifyListeners(state, FAILED);

    _failCount++;
    
    return true;
  }
  
  /**
   * Changes to the stopping state.
   *
   * @return true if the transition is allowed
   */
  public boolean toStopping()
  {
    LifecycleState state;
    
    do {
      state = _state.get();
      
      if (state.isAfterStopping() || state.isStarting())
        return false;
    } while (! _state.compareAndSet(state, STOPPING));

    _lastChangeTime = Alarm.getCurrentTime();

    if (_log != null && _log.isLoggable(_level))
      _log.log(_level, _name + " stopping");

    notifyListeners(state, STOPPING);

    return true;
  }
  
  /**
   * Changes to the idle (stopped) state.
   *
   * @return true if the transition is allowed
   */
  public boolean toIdle()
  {
    return toState(STOPPED_IDLE);
  }
  
  /**
   * Changes to the stopped state.
   *
   * @return true if the transition is allowed
   */
  public boolean toStop()
  {
    return toNextState(STOPPED);
  }
  
  /**
   * Changes to the destroying state.
   *
   * @return true if the transition is allowed
   */
  public boolean toDestroying()
  {
    return toNextState(DESTROYING);
  }
  
  /**
   * Changes to the closed state.
   *
   * @return true if the transition is allowed
   */
  public boolean toDestroy()
  {
    return toNextState(DESTROYED);
  }
  
  /**
   * Changes to the next state.
   *
   * @return true if the transition is allowed
   */
  private boolean toNextState(LifecycleState newState)
  {
    LifecycleState state;
    
    do {
      state = _state.get();
      
      if (newState.ordinal() <= state.ordinal())
        return false;
    } while (! _state.compareAndSet(state, newState));

    _lastChangeTime = Alarm.getCurrentTime();

    if (_log != null && _log.isLoggable(_lowLevel)) {
      _log.log(_lowLevel, _name + " " + newState);
    }

    notifyListeners(state, newState);

    return true;
  }
  
  /**
   * Changes to the next state.
   *
   * @return true if the transition is allowed
   */
  private boolean toState(LifecycleState newState)
  {
    LifecycleState state = _state.getAndSet(newState);

    _lastChangeTime = Alarm.getCurrentTime();

    if (_log != null && _log.isLoggable(_lowLevel))
      _log.log(_lowLevel, _name + " " + newState);

    notifyListeners(state, newState);

    return true;
  }

  //
  // listeners
  //

  /**
   * Adds a listener to detect lifecycle changes.
   */
  public void addListener(LifecycleListener listener)
  {
    synchronized (this) {
      if (isDestroyed()) {
        IllegalStateException e = new IllegalStateException("attempted to add listener to a destroyed lifecyle " + this);

        if (_log != null)
          _log.log(Level.WARNING, e.toString(), e);
        else
          Logger.getLogger(Lifecycle.class.getName()).log(Level.WARNING, e.toString(), e);

        return;
      }

      if (_listeners == null)
        _listeners = new ArrayList<WeakReference<LifecycleListener>>();

      for (int i = _listeners.size() - 1; i >= 0; i--) {
        LifecycleListener oldListener = _listeners.get(i).get();

        if (listener == oldListener)
          return;
        else if (oldListener == null)
          _listeners.remove(i);
      }

      _listeners.add(new WeakReference<LifecycleListener>(listener));
    }
  }

  /**
   * Removes a listener.
   */
  public void removeListener(LifecycleListener listener)
  {
    synchronized (this) {
      if (_listeners == null)
        return;

      for (int i = _listeners.size() - 1; i >= 0; i--) {
        LifecycleListener oldListener = _listeners.get(i).get();

        if (listener == oldListener) {
          _listeners.remove(i);

          return;
        }
        else if (oldListener == null)
          _listeners.remove(i);
      }
    }
  }

  /**
   * Returns the listeners.
   */
  private void notifyListeners(LifecycleState oldState, LifecycleState newState)
  {
    // initial must be outside synchronized to avoid any blocking
    // for fail-safe shutdown
    if (_listeners == null) {
      return;
    }
    
    synchronized (this) {
      if (_listeners != null) {
        for (int i = 0; i < _listeners.size(); i++) {
          LifecycleListener listener = _listeners.get(i).get();

          if (listener != null) {
            listener.lifecycleEvent(oldState, newState);
          }
          else {
            _listeners.remove(i);
            i--;
          }
        }
      }
    }
  }
  
  /**
   * Copies from a target state.
   *
   * @return true if the transition is allowed
   */
  public void copyState(Lifecycle source)
  {
    _state.set(source._state.get());
  }

  /**
   * Debug string value.
   */
  public String toString()
  {
    if (_name != null)
      return "Lifecycle[" + _name + ", " + getStateName() + "]";
    else
      return "Lifecycle[" + getStateName() + "]";
  }
}
