river-container-core/src/main/java/org/apache/river/container/deployer/StarterServiceLifeCycleSM.java - river-container - Git at Google

 /*
  * 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.river.container.deployer;

 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
 import java.util.logging.Level;
 import java.util.logging.Logger;
 import org.apache.river.container.MessageNames;
 import org.apache.river.container.Utils;
 import org.apache.river.container.hsm.Controller;
 import org.apache.river.container.hsm.Guard;
 import org.apache.river.container.hsm.Initial;
 import org.apache.river.container.hsm.OnEntry;
 import org.apache.river.container.hsm.OnExit;
 import org.apache.river.container.hsm.PlainStateMachineExecutor;
 import org.apache.river.container.hsm.RootState;
 import org.apache.river.container.hsm.State;
 import org.apache.river.container.hsm.StateMachineInfo;
 import org.apache.river.container.hsm.Transition;

 /**
  * Life cycle controller for "service-starter" services. Idle --> Starting -->
  * Running --> Stopping --> Idle --> Zombie
  */
 @RootState({ServiceLifeCycle.class, StatusEvents.class})
 public class StarterServiceLifeCycleSM {

     public static final int MAX_RETRY_COUNT=10;

     private static final Logger logger = Logger.getLogger(StarterServiceLifeCycleSM.class.getName(),
             MessageNames.BUNDLE_NAME);
     private ApplicationEnvironment appEnv = null;
     private StarterServiceDeployer deployer = null;
     private StatusEvents eventProxy = null;
     private ServiceLifeCycle lifeCycleProxy = null;
     private List<Throwable> exceptions = new ArrayList<Throwable>();

     public static ServiceLifeCycle newStarterServiceLifeCycle(ApplicationEnvironment appEnv, StarterServiceDeployer deployer) {
         StarterServiceLifeCycleSM machine = new StarterServiceLifeCycleSM();
         machine.appEnv = appEnv;
         machine.deployer = deployer;
         machine.eventProxy = (StatusEvents) PlainStateMachineExecutor.createProxy(machine);
         machine.lifeCycleProxy = (ServiceLifeCycle) machine.eventProxy;
         return machine.lifeCycleProxy;
     }
     @State({Idle.class, Preparing.class, Prepared.class, Starting.class,
         Failed.class, Running.class, Stopping.class, DirtyShutdown.class,
         Idle.class})
     @Initial(Idle.class)
     private Object state;
     @Controller
     private StateMachineInfo controller;

     public String getStatus() {
         return state.getClass().getSimpleName();
     }

     public String getName() {
         return appEnv.getServiceName();
     }

     public void start() {
         logger.log(Level.FINE,MessageNames.RECEIVED_START,
                 new String[]{ getStatus() });
     }

     public void startWithArgs(String[] args) {
         logger.log(Level.FINE,MessageNames.RECEIVED_START_WITH_ARGS,
                 new String[]{ getStatus() });
     }

     public void exception(Throwable ex) {
         logger.log(Level.SEVERE, MessageNames.EXCEPTION_THROWN, ex);
     }

     public class Idle {
         /*
          * To start from idle means to prepare, and then start.
          */

         @Transition(Preparing.class)
         public void start() {
             exceptions.clear();
             Runnable command = new Runnable() {
                 public void run() {
                     /* Prepare the application environment. */
                     try {
                         deployer.prepareService(appEnv);
                         eventProxy.prepareSucceeded();
                         lifeCycleProxy.start();
                     } catch (Exception ex) {
                         eventProxy.exception(ex);
                     }
                 }
             };
             deployer.workManager.queueTask(null, command);
         }

         @Transition(Preparing.class)
         public void startWithArgs(final String[] args) {
             exceptions.clear();
             Runnable command = new Runnable() {
                 public void run() {
                     /* Prepare the application environment. */
                     try {
                         deployer.prepareService(appEnv);
                         eventProxy.prepareSucceeded();
                         lifeCycleProxy.startWithArgs(args);
                     } catch (Exception ex) {
                         eventProxy.exception(ex);
                     }
                 }
             };
             deployer.workManager.queueTask(null, command);
         }

         @Transition(Preparing.class)
         public void prepare() {
             exceptions.clear();
             Runnable command = new Runnable() {
                 public void run() {
                     /* Prepare the application environment. */
                     try {
                         deployer.prepareService(appEnv);
                         eventProxy.prepareSucceeded();
                     } catch (Exception ex) {
                         eventProxy.exception(ex);
                     }
                 }
             };
             deployer.workManager.queueTask(null, command);
         }

     }

     public class Preparing {

         @Transition(Prepared.class)
         public void prepareSucceeded() {
         }

         @Transition(Failed.class)
         public void exception(Exception ex) {
             exceptions.add(ex);
         }

     }

     public class Prepared {

         @Transition(Starting.class)
         public void start() {
             Runnable command = new Runnable() {
                 public void run() {
                     /* Prepare the application environment. */
                     try {
                         deployer.launchService(appEnv, new String[0]);
                         eventProxy.startSucceeded();
                     } catch (Exception ex) {
                         eventProxy.exception(ex);
                     }
                 }
             };
             deployer.workManager.queueTask( null, command);

         }

         @Transition(Starting.class)
         public void startWithArgs(final String[] args) {
             Runnable command = new Runnable() {
                 public void run() {
                     /* Prepare the application environment. */
                     try {
                         deployer.launchService(appEnv, args);
                         eventProxy.startSucceeded();
                     } catch (Exception ex) {
                         eventProxy.exception(ex);
                     }
                 }
             };
             deployer.workManager.queueTask( null, command);

         }

         @Transition(Idle.class)
         public void stop() {}

     }

     public class Running {
         @Transition(Stopping.class)
         public void stop() {
              Runnable command = new Runnable() {
                 public void run() {
                     /* Prepare the application environment. */
                     try {
                         deployer.stopService(appEnv);
                         if(appEnv.getWorkingContext().getActiveThreadCount()==0) {
                             eventProxy.stopSucceeded();
                         } else {
                             eventProxy.stopFailed();
                         }
                     } catch (Exception ex) {
                         eventProxy.exception(ex);
                     }
                 }
             };
             deployer.workManager.queueTask(null, command);
         }
     }

     /**
      * We want the state to show as "Failed" but in reality, you can do all
      * the same commands as if you were in "Idle".  So we just extend "Idle".
      */
     public class Failed extends Idle {
     }

     public class Stopping {
         /* TODO: Implement the state machine from here to check for proper
          * shutdown.
          */

         @Transition(Idle.class)
         public void stopSucceeded() {}

         @Transition(DirtyShutdown.class)
         public void stopFailed() {}

         @Guard(Idle.class)
         public boolean areThreadsGone() {
             return appEnv.getWorkingContext().getActiveThreadCount()==0;
         }

         public void exception(Exception ex) {
             logger.log(Level.WARNING, MessageNames.EXCEPTION_WHILE_STOPPING,
                     new Object[] { Utils.stackTrace(ex) });
         }
     }

     public class DirtyShutdown {
         int retryCount=0;

         @OnEntry
         public void enter() {
             try {
             logger.log(Level.INFO, MessageNames.FAILED_CLEAN_SHUTDOWN,
                     new Object[] { appEnv.getServiceName() });
             retryCount=0;
             /* Interrupt threads,  then start interval timer to repeat. */
             appEnv.getWorkingContext().shutdown();
             setTimer();
             } catch(Throwable t) {
                 System.out.println("Got exception while entering DirtyShutdown");
                 t.printStackTrace();
             }
         }

         @Transition(Idle.class)
         public void stopped() {}

         @OnExit
         public void exit() {
             clearTimer();
         }

         public void timeout() {
             appEnv.getWorkingContext().shutdown();
             appEnv.getWorkingContext().interrupt();
             retryCount++;
         }

         @Guard(Failed.class)
         public boolean isRetryCountExceeded() {
             if (retryCount > MAX_RETRY_COUNT) {
                 logger.log(Level.INFO, MessageNames.SHUTDOWN_FAILED,
                         new Object[] { appEnv.getServiceName()});
             }
             return retryCount > MAX_RETRY_COUNT;
         }

         @Guard(Idle.class)
         public boolean areThreadsGone() {
             int nThreads=appEnv.getWorkingContext().getActiveThreadCount();
             logger.log(Level.FINE, MessageNames.N_THREADS_LEFT,
                     new Object[]{ appEnv.getServiceName(), nThreads });
             return nThreads==0;
         }
     }
     public class Starting {

         @Transition(Running.class)
         public void startSucceeded() {
         }

         @Transition(Failed.class)
         public void exception(Exception ex) {
             exceptions.add(ex);
         }
     }

     ScheduledFuture timer=null;

     public synchronized void setTimer() {
         Runnable command=new Runnable() {
             public void run() {
                 eventProxy.timeout();
                 setTimer();
             }
         };
         clearTimer();
         // We're shutting down the appEnv's working context, so we need the
         // deployer's work manager.
         timer=deployer.workManager.schedule(null, command, 2, TimeUnit.SECONDS);
     }

     public synchronized void clearTimer() {
         if (timer != null) {
             timer.cancel(true);
             timer=null;
         }
     }
 }
	/*
	* 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.river.container.deployer;

	import java.util.ArrayList;
	import java.util.List;
	import java.util.concurrent.ScheduledFuture;
	import java.util.concurrent.TimeUnit;
	import java.util.logging.Level;
	import java.util.logging.Logger;
	import org.apache.river.container.MessageNames;
	import org.apache.river.container.Utils;
	import org.apache.river.container.hsm.Controller;
	import org.apache.river.container.hsm.Guard;
	import org.apache.river.container.hsm.Initial;
	import org.apache.river.container.hsm.OnEntry;
	import org.apache.river.container.hsm.OnExit;
	import org.apache.river.container.hsm.PlainStateMachineExecutor;
	import org.apache.river.container.hsm.RootState;
	import org.apache.river.container.hsm.State;
	import org.apache.river.container.hsm.StateMachineInfo;
	import org.apache.river.container.hsm.Transition;

	/**
	* Life cycle controller for "service-starter" services. Idle --> Starting -->
	* Running --> Stopping --> Idle --> Zombie
	*/
	@RootState({ServiceLifeCycle.class, StatusEvents.class})
	public class StarterServiceLifeCycleSM {

	public static final int MAX_RETRY_COUNT=10;

	private static final Logger logger = Logger.getLogger(StarterServiceLifeCycleSM.class.getName(),
	MessageNames.BUNDLE_NAME);
	private ApplicationEnvironment appEnv = null;
	private StarterServiceDeployer deployer = null;
	private StatusEvents eventProxy = null;
	private ServiceLifeCycle lifeCycleProxy = null;
	private List<Throwable> exceptions = new ArrayList<Throwable>();

	public static ServiceLifeCycle newStarterServiceLifeCycle(ApplicationEnvironment appEnv, StarterServiceDeployer deployer) {
	StarterServiceLifeCycleSM machine = new StarterServiceLifeCycleSM();
	machine.appEnv = appEnv;
	machine.deployer = deployer;
	machine.eventProxy = (StatusEvents) PlainStateMachineExecutor.createProxy(machine);
	machine.lifeCycleProxy = (ServiceLifeCycle) machine.eventProxy;
	return machine.lifeCycleProxy;
	}
	@State({Idle.class, Preparing.class, Prepared.class, Starting.class,
	Failed.class, Running.class, Stopping.class, DirtyShutdown.class,
	Idle.class})
	@Initial(Idle.class)
	private Object state;
	@Controller
	private StateMachineInfo controller;

	public String getStatus() {
	return state.getClass().getSimpleName();
	}

	public String getName() {
	return appEnv.getServiceName();
	}

	public void start() {
	logger.log(Level.FINE,MessageNames.RECEIVED_START,
	new String[]{ getStatus() });
	}

	public void startWithArgs(String[] args) {
	logger.log(Level.FINE,MessageNames.RECEIVED_START_WITH_ARGS,
	new String[]{ getStatus() });
	}

	public void exception(Throwable ex) {
	logger.log(Level.SEVERE, MessageNames.EXCEPTION_THROWN, ex);
	}

	public class Idle {
	/*
	* To start from idle means to prepare, and then start.
	*/

	@Transition(Preparing.class)
	public void start() {
	exceptions.clear();
	Runnable command = new Runnable() {
	public void run() {
	/* Prepare the application environment. */
	try {
	deployer.prepareService(appEnv);
	eventProxy.prepareSucceeded();
	lifeCycleProxy.start();
	} catch (Exception ex) {
	eventProxy.exception(ex);
	}
	}
	};
	deployer.workManager.queueTask(null, command);
	}

	@Transition(Preparing.class)
	public void startWithArgs(final String[] args) {
	exceptions.clear();
	Runnable command = new Runnable() {
	public void run() {
	/* Prepare the application environment. */
	try {
	deployer.prepareService(appEnv);
	eventProxy.prepareSucceeded();
	lifeCycleProxy.startWithArgs(args);
	} catch (Exception ex) {
	eventProxy.exception(ex);
	}
	}
	};
	deployer.workManager.queueTask(null, command);
	}

	@Transition(Preparing.class)
	public void prepare() {
	exceptions.clear();
	Runnable command = new Runnable() {
	public void run() {
	/* Prepare the application environment. */
	try {
	deployer.prepareService(appEnv);
	eventProxy.prepareSucceeded();
	} catch (Exception ex) {
	eventProxy.exception(ex);
	}
	}
	};
	deployer.workManager.queueTask(null, command);
	}

	}

	public class Preparing {

	@Transition(Prepared.class)
	public void prepareSucceeded() {
	}

	@Transition(Failed.class)
	public void exception(Exception ex) {
	exceptions.add(ex);
	}

	}

	public class Prepared {

	@Transition(Starting.class)
	public void start() {
	Runnable command = new Runnable() {
	public void run() {
	/* Prepare the application environment. */
	try {
	deployer.launchService(appEnv, new String[0]);
	eventProxy.startSucceeded();
	} catch (Exception ex) {
	eventProxy.exception(ex);
	}
	}
	};
	deployer.workManager.queueTask( null, command);

	}

	@Transition(Starting.class)
	public void startWithArgs(final String[] args) {
	Runnable command = new Runnable() {
	public void run() {
	/* Prepare the application environment. */
	try {
	deployer.launchService(appEnv, args);
	eventProxy.startSucceeded();
	} catch (Exception ex) {
	eventProxy.exception(ex);
	}
	}
	};
	deployer.workManager.queueTask( null, command);

	}

	@Transition(Idle.class)
	public void stop() {}

	}

	public class Running {
	@Transition(Stopping.class)
	public void stop() {
	Runnable command = new Runnable() {
	public void run() {
	/* Prepare the application environment. */
	try {
	deployer.stopService(appEnv);
	if(appEnv.getWorkingContext().getActiveThreadCount()==0) {
	eventProxy.stopSucceeded();
	} else {
	eventProxy.stopFailed();
	}
	} catch (Exception ex) {
	eventProxy.exception(ex);
	}
	}
	};
	deployer.workManager.queueTask(null, command);
	}
	}

	/**
	* We want the state to show as "Failed" but in reality, you can do all
	* the same commands as if you were in "Idle". So we just extend "Idle".
	*/
	public class Failed extends Idle {
	}

	public class Stopping {
	/* TODO: Implement the state machine from here to check for proper
	* shutdown.
	*/

	@Transition(Idle.class)
	public void stopSucceeded() {}

	@Transition(DirtyShutdown.class)
	public void stopFailed() {}

	@Guard(Idle.class)
	public boolean areThreadsGone() {
	return appEnv.getWorkingContext().getActiveThreadCount()==0;
	}

	public void exception(Exception ex) {
	logger.log(Level.WARNING, MessageNames.EXCEPTION_WHILE_STOPPING,
	new Object[] { Utils.stackTrace(ex) });
	}
	}

	public class DirtyShutdown {
	int retryCount=0;

	@OnEntry
	public void enter() {
	try {
	logger.log(Level.INFO, MessageNames.FAILED_CLEAN_SHUTDOWN,
	new Object[] { appEnv.getServiceName() });
	retryCount=0;
	/* Interrupt threads, then start interval timer to repeat. */
	appEnv.getWorkingContext().shutdown();
	setTimer();
	} catch(Throwable t) {
	System.out.println("Got exception while entering DirtyShutdown");
	t.printStackTrace();
	}
	}

	@Transition(Idle.class)
	public void stopped() {}

	@OnExit
	public void exit() {
	clearTimer();
	}

	public void timeout() {
	appEnv.getWorkingContext().shutdown();
	appEnv.getWorkingContext().interrupt();
	retryCount++;
	}

	@Guard(Failed.class)
	public boolean isRetryCountExceeded() {
	if (retryCount > MAX_RETRY_COUNT) {
	logger.log(Level.INFO, MessageNames.SHUTDOWN_FAILED,
	new Object[] { appEnv.getServiceName()});
	}
	return retryCount > MAX_RETRY_COUNT;
	}

	@Guard(Idle.class)
	public boolean areThreadsGone() {
	int nThreads=appEnv.getWorkingContext().getActiveThreadCount();
	logger.log(Level.FINE, MessageNames.N_THREADS_LEFT,
	new Object[]{ appEnv.getServiceName(), nThreads });
	return nThreads==0;
	}
	}
	public class Starting {

	@Transition(Running.class)
	public void startSucceeded() {
	}

	@Transition(Failed.class)
	public void exception(Exception ex) {
	exceptions.add(ex);
	}
	}

	ScheduledFuture timer=null;

	public synchronized void setTimer() {
	Runnable command=new Runnable() {
	public void run() {
	eventProxy.timeout();
	setTimer();
	}
	};
	clearTimer();
	// We're shutting down the appEnv's working context, so we need the
	// deployer's work manager.
	timer=deployer.workManager.schedule(null, command, 2, TimeUnit.SECONDS);
	}

	public synchronized void clearTimer() {
	if (timer != null) {
	timer.cancel(true);
	timer=null;
	}
	}
	}