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()); } }