/*
    * Copyright 2010 Fraunhofer Gesellschaft, Munich, Germany,
    * for its Fraunhofer Institute for Computer Architecture and Software
    * Technology (FIRST), Berlin, Germany. All rights reserved.
    * http://www.first.fraunhofer.de/
    */
   
   package net.kwfgrid.gwes;
   
  import net.kwfgrid.gwes.exception.ActivityException;
  import net.kwfgrid.gwes.exception.LoggingException;
  import net.kwfgrid.gwes.util.HTMLFilter;
  import net.kwfgrid.gworkflowdl.structure.*;
  import org.apache.log4j.Logger;
  
  /**
   * This abstract class is to be extended in order to implement a concrete activity, such as a remote procedure call.
   * Activities are single process steps of a workflow. In order to implement your own activity class, you should
   * override the methods
   * <PRE>
   * initiateActivity()
   * startActivity()
   * simulateActivity()
   * suspendActivity()
   * resumeActivity()
   * abortActivity()
   * restartActivity()
   * cleanupActivity()
   * </PRE>
   *
   * @author Andreas Hoheisel
   *         (<a href="http://www.andreas-hoheisel.de">www.andreas-hoheisel.de</a>)
   * @version $Id: Activity.java 1534 2011-06-29 14:53:44Z hoheisel $
   * @see #initiateActivity()
   * @see #startActivity()
   * @see #simulateActivity()
   * @see #suspendActivity()
   * @see #resumeActivity()
   * @see #abortActivity()
   * @see #restartActivity()
   * @see #cleanupActivity()
   */
  public abstract class Activity {
  
      /**
       * log4j logger
       */
      public static final Logger logger = Logger.getLogger(Activity.class);
  
      /**
       * Maximum wait in MS
       */
      private static final long WAIT = Long.parseLong(System.getProperty(Constants.PROP_SYSTEM_WORKFLOW_SLEEPTIME_MAX,"60000"));
  
      /**
       * Identifier of this Activity
       */
      public final String ID;
  
      /**
       * The parent workflow handler that owns this activity
       */
      public GenericWorkflowHandler handler;
  
      /**
       * The status of this activity. Use <CODE>setStatus()</CODE> in order to modify the status.
       *
       * @see #setStatus(Status)
       */
      private Status status;
  
      /**
       * The transition occurrence contains all the workflow information needed for this activity.
       */
      protected TransitionOccurrence to;
  
      /**
       * The operation candidate contains all information about the operation and its resources.
       */
      protected OperationCandidate op;
  
      /**
       * Timeout for this activity in state running or active in milliseconds.
       */
      public long timeoutRunning;
  
      /**
       * Timeout for this activity in state active in milliseconds.
       */
      public long timeoutActive;
  
      /**
       * Fault message.
       * Is used to store human-readable error messages.
       */
      private String faultMessage;
  
      /**
       * Fault as SOAPFault object.
      */
     private SOAPFault soapFault;
 
     /**
      * Logging facility.
      */
     private GWESLogger glog;
 
     /**
      * Pending number of attempts of this activity. If attempts=1, then it is the last attempt.
      * A value of -1 means that attempts is not set.
      */
     private int attempts = -1;
 
     /**
      * time in milliseconds status being undefined and not yet initialized.
      */
     private long durationUndefined = 0L;
     private long startTimeUndefined = 0L;
 
     /**
      * time in milliseconds status being initiated and not running.
      */
     private long durationInitiated = 0L;
     private long startTimeInitiated = 0L;
 
     /**
      * time in milliseconds status being running (not including active).
      */
     private long durationRunning = 0L;
     private long startTimeRunning = 0L;
 
     /**
      * time in milliseconds status being active.
      */
     private long durationActive = 0L;
     private long startTimeActive = 0L;
 
     /**
      * time in milliseconds status being suspended.
      */
     private long durationSuspended = 0L;
     private long startTimeSuspended = 0L;
 
     /**
      * total activity duration in milliseconds.
      */
     private long durationTotal = 0L;
     private long startTimeTotal = 0L;
 
     /**
      * Default timeoutRunning for activities in state "RUNNING" or "ACTIVE" in milliseconds.
      * default = 1000*60*60*24 = 86400000 => 1 Day
      */
     public static final long DEFAULT_TIMEOUT_RUNNING = 86400000;
 
     /**
      * Default timeoutActive for activities in state "ACTIVE" in milliseconds.
      * default = 1000*60*60*2 = 7200000 => 2 Hours
      */
     public static final long DEFAULT_TIMEOUT_ACTIVE = 7200000;
 
     /**
      * Valid status for activities:
      * <br>Status <B>UNDEFINED</B>. The status remains <CODE>UNDEFINED</CODE> from the construction of the activity
      * until the method <CODE>initiateActivity()</CODE> has been called.
      * <br>Status <B>INITIATED</B>. The activity has been created and initialized but not yet been started or aborted.
      * <br>Status <B>RUNNING</B>. The activity has been started but it is not yet active or complete and it has not
      * been suspended or aborted.
      * <br>Status <B>SUSPENDED</B>. The activity is quiescent and can be returned
      * to the running state via <CODE>resumeActivity()</CODE>.
      * <br>Status <B>ACTIVE</B>. Resources related to this activity have been allocated and/or sub activities have
      * been started.
      * <br>Status <B>TERMINATED</B>. The execution of this activity instance has aborted before its normal completion.
      * This can be due to an activity exception (activity failed) or via the method <CODE>abortActivity()</CODE>.
      * <br>Status <B>COMPLETED</B>. The activity instance has fulfilled the conditions for completion. The activity
      * instance will be destroyed.
      * <br>Status <B>FAILED</B>. Activity has failed. It will be retried.
      */
     public static enum Status {
         UNDEFINED,
         INITIATED,
         RUNNING,
         SUSPENDED,
         ACTIVE,
         TERMINATED,
         COMPLETED,
         FAILED
     }
 
     /**
      * saves the last exitCode in call stack for SOAPFault
      */
     public Integer lastExitCode;
 
     /**
      * Constructor for Activity.
      * In order to access the input and output objects use the TransitionOccurrence class.
      *
      * @param handler The parent generic workflow handler.
      * @param to The TransitionOccurrence object with workflow data about this activity invocation.
      * @param op The OperationCandidate with information about the operation and its resources.
      */
     public Activity(GenericWorkflowHandler handler, TransitionOccurrence to, OperationCandidate op) throws WorkflowFormatException, LoggingException {
         this.handler = handler;
         this.ID = (handler == null) ? "Activity_"+ java.util.UUID.randomUUID() : this.handler.getNewActivityID();
         this.to = to;
         this.op = op;
         this.glog = (handler == null) ? GWESLogger.getInstance() : handler.getGlog();
         setAttempts();
         setActivityTimeouts();
         setStatus(Status.UNDEFINED);
         if (logger.isDebugEnabled()) {
             logger.debug(this.to);
         }
     }
 
     /**
      * Set status of the activity and notify threads that wait for a status change.
      */
     public synchronized void setStatus(Status status) {
         if (status != this.status) {
             Status oldStatus = this.status;
             this.status = status;
             long now = System.currentTimeMillis();
 
             try {
                 glog.logEventSP(
                         GWESLogger.Event.ACTIVITY_STATUS_CHANGE,
                         (handler == null) ? null : getHandler().getUserID(),
                         this,
                         "activityStatus",
                         (oldStatus == null) ? null : getStatusAsString(oldStatus),
                         getStatusAsString(status));
             } catch (LoggingException e) {
                 logger.warn("Exception during log: "+e,e);
             }
 
             // statistics
             switch (this.status) {
                 case UNDEFINED:
                     startTimeUndefined = now;
                     if (startTimeTotal == 0L) {
                         startTimeTotal = now;
                     }
                     break;
                 case INITIATED:
                     startTimeInitiated = now;
                     break;
                 case RUNNING:
                     startTimeRunning = now;
                     break;
                 case SUSPENDED:
                     startTimeSuspended = now;
                     break;
                 case ACTIVE:
                     startTimeActive = now;
                     break;
                 case COMPLETED:
                     if (handler != null) handler.incrementCompletedActivities(1);
                     break;
                 case TERMINATED:
                     if (handler != null) handler.incrementTerminatedActivities(1);
                     break;
                 case FAILED:
                     break;
             }
 
             if (oldStatus != null) {
                 switch (oldStatus) {
                     case UNDEFINED:
                         durationUndefined = now - startTimeUndefined;
                         break;
                     case INITIATED:
                         durationInitiated += now - startTimeInitiated;
                         break;
                     case RUNNING:
                         durationRunning += now - startTimeRunning;
                         break;
                     case SUSPENDED:
                         durationSuspended += now - startTimeSuspended;
                         break;
                     case ACTIVE:
                         durationActive += now - startTimeActive;
                         break;
                 }
             }
 
             if (isFinalStatus() || status==Status.FAILED) {
                 durationTotal = now - startTimeTotal;
                 logStatistics();
             }
 
             // notify waitForStatusChange()
             synchronized (this) {
                 this.notifyAll();
             }
         }
     }
 
     /**
      * Get the current status of this activity as int.
      *
      * @return current activity status
      * @see #getStatusAsString()
      */
     public Status getStatus() {
         return status;
     }
 
     /**
      * Wait for activity to change its status.
      *
      * @param oldStatus The old status
      * @return The new status
      * @throws InterruptedException If the thread has been interrupted
      */
     public Status waitForStatusChangeFrom(Status oldStatus) throws InterruptedException {
         while (status == oldStatus) {
             synchronized (this) {
                 this.wait(WAIT);
             }
             getStatus(); // refresh status
         }
         return status;
     }
 
     /**
      * Wait for activity to change its status to a specified status.
      *
      * @param newStatus The new status code to wait for
      * @throws InterruptedException If the thread has been interrupted
      */
     public void waitForStatusChangeTo(Status newStatus) throws InterruptedException {
         while (status != newStatus) {
             synchronized (this) {
                 this.wait(WAIT);
             }
             getStatus(); // refresh status
         }
     }
 
     /**
      * Wait for activity to change its status to COMPLETED or TERMINATED.
      *
      * @throws InterruptedException If the thread has been interrupted
      */
     public void waitForCompleteOrTerminate() throws InterruptedException {
         while (!isFinalStatus()) {
             synchronized (this) {
                 this.wait(WAIT);
             }
             getStatus(); // refresh status
         }
     }
 
     public boolean isFinalStatus() {
         return isFinalStatus(status);
     }
 
     public static boolean isFinalStatus(Status status) {
         switch(status) {
             case COMPLETED: return true;
             case TERMINATED: return true;
         }
         return false;
     }
 
     /**
      * Get the current status of the activity as string.
      *
      * @return string representing the status of the activity.
      *         This String is useful for user-readable output.
      * @see #getStatus()
      * @see #getStatusAsString(Status)
      */
     public String getStatusAsString() {
         return getStatusAsString(status);
     }
 
     /**
      * Convert the status of a activity from an integer to a string.
      *
      * @param status The status code with should be converted into a string.
      * @return string representing the status that corresponds to the status code.
      */
     public static String getStatusAsString(Status status) {
         if (status==null) return "null";
         switch(status) {
             case UNDEFINED: return "UNDEFINED";
             case INITIATED: return "INITIATED";
             case RUNNING: return "RUNNING";
             case SUSPENDED: return "SUSPENDED";
             case ACTIVE: return "ACTIVE";
             case TERMINATED: return "TERMINATED";
             case COMPLETED: return "COMPLETED";
             case FAILED: return "FAILED";
         }
         return "UNDEFINED";
     }
 
     /**
      * Get the identifier of this activity. The activity identifier is unique for this GWESEngine.
      *
      * @return The identifier of this activity
      */
     public String getID() {
         return ID;
     }
 
     /**
      * Get the parent workflow handler that owns this activity.
      *
      * @return The workflow handler.
      */
     public GenericWorkflowHandler getHandler() {
         return handler;
     }
 
     /**
      * Get the GWESLogger for this activity.
      * @return The GWESLogger.
      */
     public GWESLogger getGlog() {
         return glog;
     }
 
     /**
      * Get transition occurrence object.
      * @return
      */
     public TransitionOccurrence getTransitionOccurrence() {
         return to;
     }
 
     /**
      * Get the operation candidate.
      * @return
      */
     public OperationCandidate getOperationCandidate() {
         return op;
     }
 
     /**
      * Get the operation name of this activity.
      * @return The operation name.
      */
     public String getOperationName() {
         return op.getOperationName();
     }
 
     /**
      * Get the resource name of this activity.
      * @return The resource name.
      */
     public String getResourceName() {
         return op.getResourceName();
     }
 
     /**
      * Get the timeoutRunning of this activity.
      * @return The timeoutRunning in milliseconds.
      */
     public long getTimeoutRunning() {
         return timeoutRunning;
     }
 
     /**
      * Set the timeoutRunning of this Activity.
      * @param timeoutRunning The timout in milliseconds.
      */
     protected void setTimeoutRunning(long timeoutRunning) {
         this.timeoutRunning = timeoutRunning;
     }
 
     /**
      * Get the timeoutActive of this activity.
      * @return The timeoutActive in milliseconds.
      */
     public long getTimeoutActive() {
         return timeoutActive;
     }
 
     /**
      * Set the timeoutActive of this Activity.
      * @param timeoutActive The timout in milliseconds.
      */
     protected void setTimeoutActive(long timeoutActive) {
         this.timeoutActive = timeoutActive;
     }
 
     /**
      * Gest the human-readable fault message. Returns <code>null</code> if there is no fault message.
      * @return The fault message as String.
      */
     public String getFaultMessage() {
         if (faultMessage == null && soapFault != null) {
             faultMessage = HTMLFilter.filter(soapFault.toTokenString());
         }
         return faultMessage;
     }
 
     /**
      * Set the human-readable fault message.
      * @param faultMessage The fault message as String.
      */
     public void setFaultMessage(String faultMessage) {
         this.faultMessage = faultMessage;
     }
 
     /**
      * Append the human-readable fault message.
      * @param faultMessage The fault message as String to append.
      */
     public void appendFaultMessage(String faultMessage) {
         if (this.faultMessage == null || this.faultMessage.length() == 0) {
             this.faultMessage = faultMessage;
         } else {
             this.faultMessage += "\n" + faultMessage;
         }
     }
 
     /**
      * Get fault as SOAPFault.
      * @return The SOAP fault of this activity or <code>null</code> if there is no fault.
      */
     public synchronized SOAPFault getSoapFault() {
         if (soapFault == null && faultMessage != null) {
             SOAPFault fault = new SOAPFault("env:Server", "Activity '" + getID() + "': Exception during activity invocation");
             if (op != null) {
                 fault.setNode(op.getResourceName().startsWith("hardware:") ? op.getResourceName().split(":")[1] : op.getResourceName());
             }
             if (this.lastExitCode != null) fault.setExitCode(this.lastExitCode);
             fault.setDetail(toString() + "\n" + getFaultMessage());
             setSoapFault(fault);
         }
         return soapFault;
     }
 
     /**
      * Set SOAP fault.
      * @param soapFault The fault.
      */
     public void setSoapFault(SOAPFault soapFault) {
         this.soapFault = soapFault;
     }
 
     /**
      * Get the start time of this activity in milliseconds since 1970.
      * @return The start time
      */
     public long getStartTimeTotal() {
         return startTimeTotal;
     }
 
     /**
      * Get the duration of how long this activity was "UNDEFINED" (before initiated).
      *
      * @return The duration in milliseconds
      */
     public long getDurationUndefined() {
         return durationUndefined;
     }
 
     /**
      * Get the duration of how long this activity was "INITIATED" (before running).
      *
      * @return The duration in milliseconds
      */
     public long getDurationInitiated() {
         return durationInitiated;
     }
 
     /**
      * Get the duration of how long this activity was "RUNNING" not including the time it was "ACTIVE".
      *
      * @return The duration in milliseconds
      */
     public long getDurationRunning() {
         return durationRunning;
     }
 
     /**
      * Get the duration of how long this activity was "ACTIVE".
      *
      * @return The duration in milliseconds
      */
     public long getDurationActive() {
         return durationActive;
     }
 
     /**
      * Get the duration of how long this activity was "SUSPENDED".
      *
      * @return The duration in milliseconds
      */
     public long getDurationSuspended() {
         return durationSuspended;
     }
 
     /**
      * Get the total activity duration.
      *
      * @return The duration in milliseconds
      */
     public long getDurationTotal() {
         return durationTotal;
     }
 
     /**
      * Get the number of pending attempts for this activity.
      * "1" means, that this is the last attempt.
      * @return number of attempts or "-1" if attempts is not set.
      */
     public synchronized int getAttempts() {
         return attempts;
     }
 
     public synchronized void decreaseAttempts() {
         attempts--;
     }
 
     /**
      * Enqueue this activity in order to be processed by the ActivityStarter.
      * If the workflow handler is <code>null</code>, then directly start the activity. 
      */
     public void enqueueActivity() throws WorkflowFormatException {
         if (status == Status.INITIATED) {
             if (handler != null) {
                 handler.getEngine().getActivityQueue().enqueue(this);
             } else {
                 logger.error("Trying to enqueue activity without handler.");
             }
         } else {
             logger.error("Wrong status for enqueue activity " + getStatusAsString());
         }
     }
 
     /**
      * Get the activity status as an array of strings.
      * Example:
      * <pre>
      * ///ToDo update regarding the real output
      * "ID=hoheisel_f2968050-1d6a-11db-bacc-ad353bc1f9b1"
      * "status=COMPLETED"
      * "birthdayMs=1154003111126"
      * "durationUndefinedMs=527"
      * "durationInitiatedMs=792"
      * "durationRunningMs=0"
      * "durationActiveMs=0"
      * "durationSuspendedMs=0"
      * "durationTotalMs=1351"
      * "endTimeMs=1154003112477"
      * "level=MEMORY"
      * "description=test workflow"
      * </pre>
      * @return The current activity status as string array
      */
     public String[] getStatusArray() {
         String[] ret = new String[15];
         int i=0;
         ret[i++] = "ID="+getID();
         ret[i++] = "status="+getStatusAsString();
         ret[i++] = "activityClass=" + getClass().getName();
         ret[i++] = "operationName=" + getOperationName();
         ret[i++] = "resourceName=" + getResourceName();
         ret[i++] = "timeoutActive=" + getTimeoutActive();
         ret[i++] = "timeoutRunning=" + getTimeoutRunning();
         ret[i++] = "birthdayMs="+getStartTimeTotal();
         ret[i++] = "durationUndefinedMs=" + getDurationUndefined();
         ret[i++] = "durationInitiatedMs=" + getDurationInitiated();
         ret[i++] = "durationRunningMs=" + getDurationRunning();
         ret[i++] = "durationActiveMs=" + getDurationActive();
         ret[i++] = "durationSuspendedMs=" + getDurationSuspended();
         ret[i++] = "durationTotalMs=" + getDurationTotal();
         ret[i++] = "endTimeMs=" + (getDurationTotal() == 0L ? 0L : getStartTimeTotal()+getDurationTotal());
         return ret;
     }
 
     private void logStatistics() {
         if (logger.isDebugEnabled()) {
             logger.debug("UNDEFINED: " + getDurationUndefined() / 1000.0 + "s");
             logger.debug("INITIATED: " + getDurationInitiated() / 1000.0 + "s");
             logger.debug("RUNNING  : " + getDurationRunning() / 1000.0 + "s");
             logger.debug("ACTIVE   : " + getDurationActive() / 1000.0 + "s");
             logger.debug("SUSPENDED: " + getDurationSuspended() / 1000.0 + "s");
             logger.debug("TOTAL    : " + getDurationTotal() / 1000.0 + "s");
         }
     }
 
     private void setAttempts() throws WorkflowFormatException {
 
         if (to != null && to.transition != null) {
 
             // if transition has failed before, check for maxattempts property in transition occurrence
             String hasFailedProperty = to.transition.getProperties().get(Constants.PROP_TRANSITION_ACTIVITY_HAS_FAILED);
             if (hasFailedProperty != null && hasFailedProperty.equals(Constants.TRUE)) {
                 String attemptsStr = to.getProps().get(Constants.PROP_TOKEN_ACTIVITY_MAXATTEMPTS);
                 if (attemptsStr != null) {
                     try {
                         attempts = Integer.parseInt(attemptsStr);
                         return;
                     } catch (NumberFormatException e) {
                         throw new WorkflowFormatException("Wrong format of token property \""+Constants.PROP_TOKEN_ACTIVITY_MAXATTEMPTS+"\": " + e, e);
                     }
                 }
             }
 
             // try to get attempts from transition property
             String attemptsStr = to.transition.getProperties().get(Constants.PROP_TRANSITION_ACTIVITY_MAXATTEMPTS);
             if (attemptsStr != null) {
                 try {
                     attempts = Integer.parseInt(attemptsStr);
                     return;
                 } catch (NumberFormatException e) {
                     throw new WorkflowFormatException("Wrong format of transition property \""+Constants.PROP_TRANSITION_ACTIVITY_MAXATTEMPTS+"\": " + e, e);
                 }
             }
         }
 
         // try to get attempts from workflow property
         if (handler != null && handler.getWorkflow() != null) {
             Object wfObj = handler.getWorkflow();
             if (wfObj instanceof Workflow) {
                 String attemptsStr = ((Workflow) wfObj).getProperties().get(Constants.PROP_ACTIVITY_MAXATTEMPTS);
                 if (attemptsStr != null) {
                     try {
                         attempts = Integer.parseInt(attemptsStr);
                         return;
                     } catch (NumberFormatException e) {
                         throw new WorkflowFormatException("Wrong format of workflow property \""+Constants.PROP_TRANSITION_ACTIVITY_MAXATTEMPTS+"\": " + e, e);
                     }
                 }
             }
         }
 
         // try to get attempts from system properties
         String attemptsStr = System.getProperty(Constants.PROP_SYSTEM_GWES_ACTIVITY_MAXATTEMPTS);
         if (attemptsStr != null) {
             try {
                 attempts = Integer.parseInt(attemptsStr);
                 return;
             } catch (NumberFormatException e) {
                 throw new WorkflowFormatException("Wrong format of property \""+Constants.PROP_SYSTEM_GWES_ACTIVITY_MAXATTEMPTS+"\" in gwes.properties: " + e, e);
             }
         }
 
         // default
         attempts = 1;
     }
 
     private void setActivityTimeouts() throws WorkflowFormatException {
         // no to => no transition => nothing to set.
         if (to == null) {
             logger.warn("setActivityTimeouts(): Transition occurrence is null for "+ID);
             return;
         }
 
         // set activity timeouts
         String timeoutProperty = to.transition.getProperties().get(Constants.PROP_TRANSITION_TIMEOUT);
         String timeoutRunningProperty = to.transition.getProperties().get(Constants.PROP_TRANSITION_TIMEOUT_RUNNING);
         String timeoutActiveProperty = to.transition.getProperties().get(Constants.PROP_TRANSITION_TIMEOUT_ACTIVE);
         // timeout.running -> timeout -> gwes.activity.timeout.running -> DEFAULT_TIMEOUT_RUNNING
         if (timeoutRunningProperty != null) {
             try {
                 setTimeoutRunning(Long.parseLong(timeoutRunningProperty));
             } catch (NumberFormatException e) {
                 throw new WorkflowFormatException("Wrong format of property \"timeout.running\": " + e, e);
             }
         } else if (timeoutProperty != null) {
             try {
                 setTimeoutRunning(Long.parseLong(timeoutProperty));
             } catch (NumberFormatException e) {
                 throw new WorkflowFormatException("Wrong format of property \"timeout\": " + e, e);
             }
         } else {
             setTimeoutRunning(Long.parseLong(System.getProperty(Constants.PROP_SYSTEM_GWES_ACTIVITY_TIMEOUT_RUNNING, "" + Activity.DEFAULT_TIMEOUT_RUNNING)));
         }
 
         // timeout.active -> timeout -> gwes.activity.timeout.active -> DEFAULT_TIMEOUT_ACTIVE
         if (timeoutActiveProperty != null) {
             try {
                 setTimeoutActive(Long.parseLong(timeoutActiveProperty));
             } catch (NumberFormatException e) {
                 throw new WorkflowFormatException("Wrong format of property \"timeout.active\": " + e, e);
             }
         } else if (timeoutProperty != null) {
             try {
                 setTimeoutActive(Long.parseLong(timeoutProperty));
             } catch (NumberFormatException e) {
                 throw new WorkflowFormatException("Wrong format of property \"timeout\": " + e, e);
             }
         } else {
             setTimeoutActive(Long.parseLong(System.getProperty(Constants.PROP_SYSTEM_GWES_ACTIVITY_TIMEOUT_ACTIVE, "" + Activity.DEFAULT_TIMEOUT_ACTIVE)));
         }
     }
 
     // a concrete implementation should override the following methods
 
     /**
      * Initiate this activity. Status should switch to INITIATED. Method should only work if the status was
      * UNDEFINED before. Implement this method in all derived classes!
      */
     public abstract void initiateActivity() throws ActivityException;
 
     /**
      * Start this activity. Status should switch to RUNNING. Implement this method in all derived classes!
      */
     public abstract void startActivity() throws ActivityException, WorkflowFormatException;
 
     /**
      * Simulate this activity. Status should switch to RUNNING.
      * This method is equivalent to "startActivity()", however the invocation of the activity is only simulated and
      * takes minimum amount of time. The performance results (duration, memory consumption etc.) of the activity should
      * be returned as properties of the output tokens.
      * Implement this method in all derived classes!
      */
     public abstract void simulateActivity() throws ActivityException, WorkflowFormatException;
 
     /**
      * Suspend this activity. Status should switch to SUSPENDED. Implement this method in all derived classes!
      */
     public abstract void suspendActivity() throws ActivityException;
 
     /**
      * Resume this activity. Status should switch to RUNNING. Implement this method in all derived classes!
      */
     public abstract void resumeActivity() throws ActivityException;
 
     /**
      * Abort this activity. Status should switch to TERMINATED. Implement this method in all derived classes!
      */
     public abstract void abortActivity() throws ActivityException;
 
     /**
      * Restart this activity. Status should switch to INITIATED. Implement this method in all derived classes!
      */
     public abstract void restartActivity() throws ActivityException;
 
     /**
      * Cleans up all temporary data produced by this activity. Implement this method in all derived classes!
      */
     public abstract void cleanupActivity() throws ActivityException;
 
     /**
      * Each activity should be able to give some information about itself using the toString() method.
      * @return String containing human readable information about the activity.
      */
     public String toString() {
         StringBuffer buffer = new StringBuffer();
         buffer.append(getClass().getName()).append('[');
         buffer.append("ID=").append(ID);
         if (to != null) {
             buffer.append("; ").append(to);
         }
         if (op != null) {
             buffer.append("; OperationName=").append(op.getOperationName());
             buffer.append("; ResourceName=").append(op.getResourceName());
         }
         buffer.append(']');
         return buffer.toString();
     }
 
     /**
      * Put SOAP Fault on each output token that is connected with a edge expression.
      * Does NOT overwrite existing tokens!
      * @throws net.kwfgrid.gworkflowdl.structure.WorkflowFormatException
      */
     protected void putFaultTokenOnOutputPlaces() throws WorkflowFormatException {
         if (to == null) return;
         logger.debug("putting one fault token on each of the output places...");
 
         for (TokenParameter tp : to.tokens) {
             switch (tp.scope) {
                 case OUTPUT:
                     if (tp.token != null) continue;
                     String edgeExpression = tp.edge.getExpression();
                     if (edgeExpression != null && edgeExpression.length() > 0) {
                         try {
                             tp.token = getSoapFault().toToken();
                         } catch (NullPointerException e) {
                             logger.error("NullPointerException during putting fault tokens on output places: "+e,e);
                         }
                     }
                     break;
             }
         }
     }
 
 }