FTS Framework for JADE

• create the worker (ExampleWorker)

  
  	// Create an instance of ftsFramework.Util
  	selfUtil = new Util();
  
  	...
  
  	tAgent = new AID("TAgent", false);
  
  	...	
  
  	// Create an instance of WorkerCreater
  	wc = new WorkerCreater((Agent)this);
  
  	...
  
  	// Create an instance of ExampleWorker, called WorkerA
  	// Set (AID)tAgent.clone() as the TAgent
  	// Set this agent as the terminator
  	// Set the heartbeat period as 5 seconds and the missing tolerance as 5
  	// Set this host as the home host
  	// You may also passing java.lang.Object[] parameters as customer parameters to the worker but it is skipped here
  	AgentController ac = (wc.createWorker("WorkerA", "example.ExampleWorker", (AID)tAgent.clone(), 
  				(AID)getAID().clone(), new Long(5000), new Integer(5), homeID));
  
  	// Register the worker to the TAgent
  	// Using "0000" as the secret ID which must be supplied to the TAgent for further communcation
  	// The last parameter is reserved for application specific data but it is not necessary in this example 
  	if (selfUtil.regWorker(myAgent, new AID("WorkerA",false), tAgent, "0000", new byte[0]))
  	{
  		ac.start();
  	}
  	else
  	{
  		System.out.println("Fails to create a worker");
  		doDelete();
  	}
  

• wait for the response from the worker
• ask the TAgent to terminate the current session
• retrieve the results of re-execution from TAgent

  	// Tell the TAgent the current session for worker is ended
  	// "0000" is the secret ID set before
  	// An instance of ChainStatus is replied from the TAgent
  	ChainStatus chain = selfUtil.enforceEnd(myAgent, new AID("WorkerA",false), tAgent, "0000");
  	if (chain != null)
  	{
  		// Get the list of StageElement which contains all information for each stage
  		ArrayList list = chain.getStageElements();
  		for (int i = 0; i < list.size(); i++)
  		{
  			// We only want to know the re-exeuction result, either true - correct or false - incorrect
  			System.out.println(i+" "+ (Boolean)((StageElement)list.get(i)).getReResult().get(0));
  		}
  	}
  	else
  	{
  		System.out.println("Failure to request");
  	}
  

• migrate to Container-1
• contact Server (sending and receiving message through FTSLayer)
• migrates back to home host and terminates
• The execution of Worker is shown in Execution Flow of Worker.
• The task is done in the method normalExecution. step counts the step of the example worker and also used to determine the exeuciton on different host. Note that initStep is the initial value of step and it is also used as the initial state of the worker.

  	protected void normalExecution()
  	{
  			if (step == 0)					// do nth in the home host
  		{
  			initStep = step;			// assign the initial value of step to initStep
  			step++;
  			setStageEnd();				// end the stage
  		}
  		else if (step == 1)				// contact the server in Container-1
  		{
  			try
  			{
  				ACLMessage msg = new ACLMessage(ACLMessage.INFORM);
  				msg.addReceiver(new AID("Server", false));
  				msg.setContent("Message from Worker");
  				sendFTS(msg);			// using sendFTS() to send message instead of send()
  				
  				ACLMessage reMsg = blockingReceiveFTS();
  				System.out.println("Worker receives "+reMsg.getContent());
  			}
  			catch (Exception e)
  			{
  				e.printStackTrace();
  			}
  			initStep = step;
  			step++;
  			setStageEnd();
  		}
  		else if (step == 2)				// response to the creater and terminate
  		{
  			try
  			{
  				ACLMessage msg = new ACLMessage(ACLMessage.INFORM);
  				msg.addReceiver(new AID("Creater", false));
  				msg.setContent("End");
  				send(msg);
  			}
  			catch (Exception e)
  			{
  				e.printStackTrace();
  			}
  			
  			System.out.println("Going to terminate");
  			setDone();
  			doDelete();
  		}
  	}
  

• getInitState() and getFinalState() are used by the framework to record down the initial state and final state of the worker.

  	protected byte[] getInitState()
  	{
  		return (String.valueOf(initStep)).getBytes();
  	}
  	
  	protected byte[] getFinalState()
  	{
  		return (String.valueOf(step)).getBytes();
  	}
  

• nextHost() is called automatically at the end of each stage and determines the next host.

  	protected ContainerID nextHost()
  	{
  		ContainerID id = new ContainerID();
  		if (step == 1)
  		{
  			id.setName("Container-1");
  			id.setAddress("localhost");
  		}
  		else if (step == 2)
  		{
  			id = getHomeID();
  		}
  		return id;
  	}
  

• If Worker crashes, a new Worker will be created by a monitor. During recovery, restoreState is called to restore the state and setupRecovery is similar to setup() for any initial task.

  	protected void restoreState(byte[] state)
  	{
  		String str = new String(state);
  		initStep = Integer.parseInt(str);
  		step = Integer.parseInt(str);
  	}
  	
  	protected void setupRecovery(boolean isRolling)
  	{
  		doMove(nextHost());
  	}
  

• carry out the exeuction tracing
• structural similar to ExampleWorker and the exeuction flow is shown in Exeuciton Flow of Checker
• monitoredVarEquals and stateEquals are used to check for the security. In this example, only stateEquals is used.

  	// no monitored variables are used in this example
  	public boolean monitoredVarEquals(String varName, Serializable var1, Serializable var2)
  	{
  		return true;
  	}
  
  	// compare the final state of the exeuction and re-execution
  	public boolean stateEquals(byte[] state1, byte[] state2)
  	{
  
  		String str1 = new String(state1);
  		int step1 = Integer.parseInt(str1);
  
  		String str2 = new String(state2);
  		int step2 = Integer.parseInt(str2);
  
  		return (step1 == step2);
  	}
  

• Set the appropriate checker(s) in each stage

  	// Set the checker for each stage
  	protected void setCheckers(ChainStatus chain, boolean isPush)
  	{
  		// There is only 1 checker in this example
  		chain.addSuggestedChecker(chain.getMaxID(), new AID("Checker", false));
  	}
  

• a usual Jade Agent
• stay in the Container-1
• receive the message from Worker
• response to Worker

Running

1. put the ftsFramework.jar into $jade/lib and .java files into $jade/example
2. compile all java files
3. start the Jade main container, Container-1 and Container-2
4. start the ExampleTAgent and ExampleChecker, called TAgent and Checker, at Container-2
5. start the ExampleServer, called Server, at Container-1
6. start the ExampleCreater, called Creater, at the main conatiner

Example 2

In this example, the usage of dependent partial rollback is shown. As mentioned before, step is a basic unit and treated as a transaction. In the Dependent Partial Rollback approach, a step of an agent is a transaction (step, stage and transaction are used interchangeably in this page). Hence, the life of an agent can be treated as a chained-transaction. In a more complicated case, there may be several chained-transactions mixed together. When an agent needs to rollback to the target transaction (the earliest transaction that should be rolled back to), all affected transactions should also be rolled back in the reverse order of their execution. The selection of transactions to be rolled back based on monitored variables and chained-transaction. The state of the monitored variables are guaranteed to be consistent. Moreover, all transactions in the same chained-transaction and after the rollback point will be rolled back.

Basic Flow

There are four containers in this example. Main-Container (called host 0) is used as the home host. Worker migrates from home host to Container-1 and Container-2 alternatively. Totally, it carries out 8 steps on them. On the odd step, it writes on the monitored variable. On the even step, it read from monitored variable. Also, steps 1 to 4 belong to chained-transaction 1 and steps 5 to 8 belong to chained-transaction 2. After step 8, it determines the step to rollback. After rollback, it migrates back to home host.

Coding

• normalExecution is different to ExampleWorker but just logically different, so it is not explained here again
• determinant is used to determine if rollback should be carried out and the target transaction

  	protected boolean determinant()
  	{
  		if (step == 9)					// the end of step 8, so it is step 9
  		{
  			Random rand = new Random(0);		// remove the seed to see different effects or just hard code a value, etc
  			int temp = rand.nextInt(8)+1;
  			System.out.println("Going to rollback step "+temp);
  			setToRoll(temp);			// set the target transaction
  			return true;
  		}
  		else
  		{
  			return false;
  		}
  	}
  

• getCurrentCTID is used to return the chained-transction ID

  	protected int getCurrentCTID()
  	{
  		if (step < 6)				// because step is increased in normalExeuction, it refers to the end of step 4. i.e. Step 1-4.
  		{
  			return 1;
  		}
  		else
  		{
  			return 2;
  		}
  	}
  

• compensations is used to compensate the effect of the normalExecution

  	protected void compensations()
  	{
  		System.out.println("Step "+getRollingID()+" is going to be rolled back");
  		if (getWrittenFlags(getRollingID())[0])			// check if it is writen in the step which is going to be rolled back
  		{
  			writeMonitoredVar("Var1", (Serializable)getMonitoredInitVars("Var1"));		// overwrite with the init. value
  		}
  		setStageEnd();
  	}
  

• initiar is called after rollback

  	protected void initiator()
  	{
  		doMove(nextHost());			// move to the next host after rollback
  	}
  

• structurally similar to ExampleWorker2
• monitoredVarEquals is used to compare the state of monitored variables

  	public boolean monitoredVarEquals(String varName, Serializable var1, Serializable var2)
  	{
  		if (var1 != null && var2 != null)
  		{
  			return (((Integer)var1).intValue() == ((Integer)var2).intValue());
  		}
  		else if (var1 == null && var2 == null)
  		{
  			return true;
  		}
  		return false;
  	}
  

• same as ExampleCreater, except it creates ExampleWorker2 instead of ExampleWorker

• same as ExampleTAgent

Running

1. put the ftsFramework.jar into $jade/lib and .java files into $jade/example
2. compile all java files
3. start the Jade main container, Container-1, Container-2 and Container-3
4. start the ExampleTAgent2 and ExampleChecker2, called TAgent and Checker, at Container-3
5. start the ExampleCreater2, called Creater, at the main conatiner

Execution flow in Worker

Useful Methods

setupFTS()	The entry point of the newly created Worker
restoreState()	The entry point of the re-created Worker
setupRecovery()	For housekeeping task after re-create
initiator()	For housekeeping task after rollback
normalExecution()	Normal execution
determinant()	Determining if rollback is necessary and make it down in RBList
compensation()	Compensating action
nextHost()	Returning the identity of the next host

Execution flow in Checker

Messaging in the FTS Framework

Further Information

For further information about Flexible Monitor Chain, Dependent Partial Rollback and Execution Tracing with Randomly Selected Hosts, please refer to the references