package edu.stanford.peer.rbtm.engine; import java.util.*; import edu.stanford.peer.rbtm.RBTMConstants; import edu.stanford.peer.rbtm.credential.*; import edu.stanford.peer.rbtm.util.*; /** * A graph engine is a proof graph which may optionally contain a predicate * function. This implementation is a tightly coupled directed credential * graph and credential index. * * @deprecated */ public class CredentialManager implements java.io.Serializable, ProofGraph, RBTMConstants { static final public Iterator emptyIt = new ArrayList(1).iterator(); static final public Collection emptyCollection = new ArrayList(1); /** stores all the credentials */ private HashSet credentials = new HashSet(); /** an index from issuers to credential collections */ private HashMap indexByIssuer = new HashMap(); /** an index from roles to credential collections */ private HashMap indexByRole = new HashMap(); /** an index from subjects to collections of credentials */ private HashMap indexBySubject = new HashMap(); /** predicate function which could be null */ private Predicate pred = null; private int track; private SolutionFilter solutionFilter; // a proof queue transient private ProofQueue proofQueue = new SimpleProofQueue(); transient private HashMap nodeTable = new HashMap(); public CredentialManager(Set credSet, int trackType, SolutionFilter solFilter) { this(trackType, solFilter); addCredentials(credentials); } public CredentialManager(int trackType, SolutionFilter solFilter) { track = trackType; solutionFilter = solFilter; } public CredentialManager() { this(TRACK_NONE, new DefaultSolutionFilter()); } public void reinit() { proofQueue = new SimpleProofQueue(); nodeTable = new HashMap(); } synchronized public void addCredentials(Collection credentials) { reinit(); Iterator credIt = credentials.iterator(); while (credIt.hasNext()) { addCredential((StaticCredential)credIt.next()); } } synchronized public void removeCredentials(Collection credentials) { reinit(); Iterator credIt = credentials.iterator(); while (credIt.hasNext()) { removeCredential((StaticCredential)credIt.next()); } } synchronized public boolean addCredential(StaticCredential cred) { // Make sure that no duplicate Credential exists if (credentials.contains(cred)) { Debug.debugInfo("trying to add existing credential: " + cred); return false; } Debug.debugInfo("adding credential: " + cred); credentials.add(cred); addIndexFor(cred); ProofNode node = getNode(cred.getDefinedRole()); if (node != null) { node.invalidateBackward(); } node = getNode(cred.getSubject()); if (node != null) { node.invalidateForward(); } return true; } synchronized public void removeCredential(StaticCredential cred) { if (credentials.contains(cred)) { Debug.debugInfo("removing credential: " + cred); reinit(); credentials.remove(cred); removeIndexFor(cred); } else { Debug.debugInfo("trying to remove nonexistent credential: " + cred); //// throw Exception } } private void addIndexFor(StaticCredential cred) { Entity e = cred.getIssuer(); ArrayList credList = (ArrayList)indexByIssuer.get(e); if (credList == null) { credList = new ArrayList(40); indexByIssuer.put(e, credList); } credList.add(cred); // Code to deal with indexByRole Role r = cred.getDefinedRole(); credList = (ArrayList) indexByRole.get(r); if (credList == null) { credList = new ArrayList(10); indexByRole.put(r, credList); } credList.add(cred); EntityExpression subject = cred.getSubject(); if(subject instanceof Intersection) { Iterator parts = ((Intersection)subject).getParts(); while(parts.hasNext()) { EntityExpression partialSolution = (EntityExpression)parts.next(); credList = (ArrayList) indexBySubject.get(subject); if (credList == null) { credList = new ArrayList(10); indexBySubject.put(partialSolution, credList); } credList.add(cred); } } else { credList = (ArrayList) indexBySubject.get(subject); if (credList == null) { credList = new ArrayList(10); indexBySubject.put(subject, credList); } credList.add(cred); } } private void removeIndexFor(StaticCredential cred) { ((ArrayList)indexByIssuer.get(cred.getIssuer())).remove(cred); ((ArrayList)indexByRole.get(cred.getDefinedRole())).remove(cred); ((ArrayList)indexBySubject.get(cred.getSubject())).remove(cred); } /* public void addRole(Role role) { if (! indexByRole.containsKey(role)) { indexByRole.put(role, new ArrayList()); } } */ synchronized public Collection getCredentialsIssuedBy(Entity e) { Collection credentials = (Collection)indexByIssuer.get(e); if (credentials == null) { return emptyCollection; } else { return credentials; } } synchronized public Iterator findCredentialsDefiningRole(Role r) { ArrayList credList = (ArrayList) indexByRole.get(r); if (credList == null) { return emptyIt; } else { return credList.iterator(); } } synchronized public Iterator findCredentialsBySubject(EntityExpression subject) { ArrayList credList = (ArrayList) indexBySubject.get(subject); if (credList == null) { return emptyIt; } else { return credList.iterator(); } } synchronized public Iterator findCredentialsByPartialSubject(EntityExpression subject) { // Using a vector copies the arraylist so we don't remove from it ArrayList credList = (ArrayList)indexBySubject.get(subject); if (credList == null) { return emptyIt; } credList = (ArrayList)credList.clone(); Iterator i = credList.iterator(); while(i.hasNext()) { // remove credential which aren't intersections StaticCredential cred = (StaticCredential)i.next(); if(!(cred.getSubject() instanceof Intersection)) { i.remove(); } } return credList.iterator(); } /* boolean hasCredentialsForSubject(EntityExpression re) { return findCredentialsBySubject(re).hasNext(); } */ // Find out all Roles that roleExp belongs to synchronized public ResultEvidenceMap forwardSearch(EntityExpression roleExp) { ProofNode goalNode = addForwardNode(roleExp); while (proofQueue.hasUnexploredForwardNodes()) { proofQueue.nextUnexploredForwardNode().forwardProcess(); } return goalNode.getForwardSolutions(); } // Find out all members of roleExp synchronized public ResultEvidenceMap backwardSearch(EntityExpression roleExp) { ProofNode goalNode = addBackwardNode(roleExp); while (proofQueue.hasUnexploredBackwardNodes()) { proofQueue.nextUnexploredBackwardNode().backwardProcess(); } return goalNode.getBackwardSolutions(); } public ProofNode addForwardNode(EntityExpression roleExp) { ProofNode node = addNode(roleExp); proofQueue.addForwardNode(node); return node; } public ProofNode addBackwardNode (EntityExpression roleExp) { ProofNode node = addNode(roleExp); proofQueue.addBackwardNode(node); return node; } /** * Add a node corresponding to a role expression, make sure that the * node is not added twice. */ private ProofNode addNode (EntityExpression roleExp) { ProofNode node = (ProofNode)nodeTable.get(roleExp); if (node == null) { node = createProofNode(roleExp); nodeTable.put(roleExp, node); } return node; } private ProofNode getNode(EntityExpression roleExp) { return (ProofNode)nodeTable.get(roleExp); } private ProofNode createProofNode (EntityExpression roleExp) { if (roleExp instanceof Role) { return new RoleProofNode(this, (Role)roleExp, track); } else if (roleExp instanceof LinkedRole) { return new LinkedRoleProofNode(this, (LinkedRole)roleExp, track); } else if (roleExp instanceof Intersection) { return new IntersectionProofNode(this,(Intersection)roleExp,track); } else { return new EntityProofNode(this, (Entity)roleExp, track); } } public ForwardSolution getForwardSolution(EntityExpression re) { return solutionFilter.getForwardSolution(re); } public BackwardSolution getBackwardSolution(EntityExpression re) { return solutionFilter.getBackwardSolution(re); } public String toString() { return "credentials=" + credentials.toString() + "\n" + "indexByIssuer=" + indexByIssuer.toString() + "\n" + "indexByRole=" + indexByRole.toString() + "\n" + "indexBySubject=" + indexBySubject.toString(); } private String getSubjectIndexs() { StringBuffer outBuf = new StringBuffer(); Iterator keyIt = indexBySubject.keySet().iterator(); while (keyIt.hasNext()) { Object o = keyIt.next(); if (o instanceof Role) { outBuf.append("Role ").append(o.toString()).append("\n"); Role r = (Role) o; outBuf.append("Base is ").append(r.getBase().getClass()).append("\n"); outBuf.append("RoleName is ").append(r.getName().getClass()).append("\n"); } } return outBuf.toString(); } public HashSet getChain(EntityExpression source, EntityExpression target) { return new HashSet(); } public Predicate getPredicate() { return pred; } }