Index: fedd/abac-src/ttg/process/StaticNegotiator.java
===================================================================
--- fedd/abac-src/ttg/process/StaticNegotiator.java	(revision eec716b04d02fc83402be818a98dda0175afb080)
+++ fedd/abac-src/ttg/process/StaticNegotiator.java	(revision eec716b04d02fc83402be818a98dda0175afb080)
@@ -0,0 +1,132 @@
+package com.nailabs.abac.process;
+
+import com.nailabs.abac.trust.*;
+import com.nailabs.abac.test.*;
+import edu.stanford.peer.rbtm.credential.Entity;
+
+/**
+ * This class is a concrete negotiator implementation isolated from the 
+ * underlying communications transport mechanism.
+ */
+public class StaticNegotiator {
+    /**
+     * The peer with which this instance negotiates.
+     */
+    protected StaticNegotiator peer;
+
+    /** 
+     * The context for the current negotiation, including a trust target graph,
+     * strategy, and frontier manager instances.
+     */
+    protected NegotiationContext context;
+
+    /**
+     * Default constructor for the client-side negotiatior. This negotiator
+     * is requesting access to a resource.
+     */
+    public StaticNegotiator(NegotiationContext nc) { 
+	context = nc;
+    }
+
+    /**
+     * Constructor for the server-side negotiator. This negotiator has a 
+     * resource that needs protection. 
+     */
+    public StaticNegotiator(TargetNode root, StaticNegotiator peer) {
+        setPeer(peer); 
+    } 
+    
+    public Entity getSelf() 
+    {
+        return context.getSelf();
+    }
+
+    /**
+     * initial a new root node and start the negotiation process. 
+     */
+    public boolean negotiate() {
+	TTG graph = context.getGraph();
+	Strategy s = context.getStrategy();
+	SatisfactionState state;
+	int i = 0;
+	debug("pre-processing locally...");
+	//perform strategy once
+	s.iterate();
+	Message changes = graph.getChanges();
+	graph.reset();
+	do {
+	    debug("processing cycle = " + ++i);
+	    debug("sending message " + changes);
+            System.out.println("Sending message: ");
+            System.out.println(changes.toXML());
+        try {
+            Message updates = peer.receive(changes);
+            debug("receiving message " + updates);
+            changes = receive(updates);
+        }
+        catch(Exception ex) {
+            Debug.rbtmStop();
+            ex.printStackTrace();
+            return false;
+        }
+	    state = new SatisfactionState(context.getStrategy().getSatisfactionState());
+	    debug("StaticNegotiator:  primary trust target  is " + state);
+	}while(state.getState() == SatisfactionState.UNKNOWN && i <= 100);
+	// out of the loop so we need to return success or failure
+	return (state.getState() == SatisfactionState.SATISFIED);
+    }
+
+
+    /** set the other negotiator dynamically */
+    public void setPeer(StaticNegotiator peer) {
+	this.peer = peer;
+    }
+
+    public void setRoot(TrustTarget tt) {
+	context.getGraph().setRoot(tt);
+	//TargetNode node = (TargetNode)context.getGraph().getNodeByHash(tt);
+	//context.getStrategy().addToWorklist(node);
+    }
+    
+
+    /** 
+     * Synchronously receive a message which can contain multiple operations 
+     * from an peer and then return the updates to the originating 
+     * peer.
+     */
+    public Message receive(Message msg) throws Exception {
+	Strategy strategy = context.getStrategy();
+	TTG graph = context.getGraph();
+	Message results = null;
+
+	//for(int i = 0, max = msg.getOperationsCount(); i < max; i++) {
+	//    System.out.println("max = " + max);
+	//   try {
+	//	Operation op = msg.getNextOperation();
+	//	op.perform(graph);
+	//    }
+	//    catch(Exception ex) {
+	//	ex.printStackTrace();
+	//    }
+	//}
+	debug("begin receive");
+	graph.update(msg);
+	debug("graph has been updated");
+	strategy.process(msg);
+	debug("strategy has processed the work list");
+	results = graph.getChanges();
+	debug("grabbing the delta list = " + results);
+	graph.reset();
+
+	debug("end receive");	
+	return results;
+    }
+    
+    /** convenience method for printing messages */
+    public void debug(String message) {
+	StringBuffer buff = new StringBuffer("StaticNegotiator[");
+	buff.append(context.getSelf()).append("]: ").append(message);
+	//System.out.println(buff);
+	Debug.debug("negotiate", buff.toString());
+    }
+}
