notificationservice.java

java实现的P2P多agent中间件

				tn.changedBehaviourState(ev);
			}
			
			Iterator itMessages = messages.iterator();
			while(itMessages.hasNext()) {
				ACLMessage msg = (ACLMessage)itMessages.next();
				MessageEvent ev = new MessageEvent(MessageEvent.POSTED_MESSAGE, msg, null, targetName, myContainer.getID());
				tn.postedMessage(ev);
			}
		}
		
		private void debugOff(AID introspectorName, AID targetName) throws IMTPException {
			ToolNotifier tn = findNotifier(introspectorName);
			if(tn != null) { 
				tn.removeObservedAgent(targetName);
			}
			
			boolean resetGenerateBehaviourEvents = true;
			synchronized (debuggers) {
				List l = (List) debuggers.get(targetName);
				if (l != null) {
					l.remove(introspectorName);
					if (l.size() > 0) {
						// There is still at least 1 debugger debugging the agent 
						// Do not stop generation of behaviour events
						resetGenerateBehaviourEvents = false;
					}
					else {
						debuggers.remove(targetName);
					}
				}
			}
			
			if (resetGenerateBehaviourEvents) {
				Agent a = myContainer.acquireLocalAgent(targetName);
				if (a != null) {
					a.setGenerateBehaviourEvents(false);
				}
				myContainer.releaseLocalAgent(targetName);
			}
		}
	} // End of ServiceComponent class
	
	
	/**
	 * Inner class NotificationHelperImpl
	 */
	private class NotificationHelperImpl implements NotificationHelper {
		public void init(Agent a) {
		}
		
		public void registerMessageListener(MessageListener ml) {
			List l = messageListeners.startModifying();
			l.add(ml);
			messageListeners.stopModifying();
		}
		
		public void deregisterMessageListener(MessageListener ml) {
			List l = messageListeners.startModifying();
			l.remove(ml);
			messageListeners.stopModifying();    
		}
		
		public void registerAgentListener(AgentListener al) {
			List l = agentListeners.startModifying();
			l.add(al);
			agentListeners.stopModifying();    
		}
		
		public void deregisterAgentListener(AgentListener al) {
			List l = agentListeners.startModifying();
			l.remove(al);
			agentListeners.stopModifying();    
		}
		
		public void registerContainerListener(ContainerListener cl) {
			List l = containerListeners.startModifying();
			l.add(cl);
			containerListeners.stopModifying();    
		}
		
		public void deregisterContainerListener(ContainerListener cl) {
			List l = containerListeners.startModifying();
			l.remove(cl);
			containerListeners.stopModifying();    
		}
	} // END of inner class NotificationHelperImpl
	
	/////////////////////////////////////
	// Event dispatching methods
	/////////////////////////////////////
	private void fireSentMessage(ACLMessage msg, AID sender, AID receiver) {
		// NOTE: A normal synchronized block could create deadlock problems
		// as it prevents concurrent scannings of the listeners list.
		List l = messageListeners.startScanning();
		if (l != null) {
			MessageEvent ev = new MessageEvent(MessageEvent.SENT_MESSAGE, msg, sender, receiver, myID());
			Iterator it = l.iterator();
			while (it.hasNext()) {
				MessageListener ml = (MessageListener) it.next();
				ml.sentMessage(ev);
			}
			messageListeners.stopScanning();
		}	
	}
	
	private void firePostedMessage(ACLMessage msg, AID receiver) {
		// NOTE: A normal synchronized block could create deadlock problems
		// as it prevents concurrent scannings of the listeners list.
		List l = messageListeners.startScanning();
		if (l != null) {
			MessageEvent ev = new MessageEvent(MessageEvent.POSTED_MESSAGE, msg, null, receiver, myID());
			Iterator it = l.iterator();
			while (it.hasNext()) {
				MessageListener ml = (MessageListener) it.next();
				ml.postedMessage(ev);
			}
			messageListeners.stopScanning();
		}
	}
	
	private void fireReceivedMessage(ACLMessage msg, AID receiver) {
		// NOTE: A normal synchronized block could create deadlock problems
		// as it prevents concurrent scannings of the listeners list.
		List l = messageListeners.startScanning();
		if (l != null) {
			MessageEvent ev = new MessageEvent(MessageEvent.RECEIVED_MESSAGE, msg, null, receiver, myID());
			Iterator it = l.iterator();
			while (it.hasNext()) {
				MessageListener ml = (MessageListener) it.next();
				ml.receivedMessage(ev);
			}
			messageListeners.stopScanning();
		}
	}
	
	private void fireRoutedMessage(ACLMessage msg, Channel from, Channel to) {
		// NOTE: A normal synchronized block could create deadlock problems
		// as it prevents concurrent scannings of the listeners list.
		List l = messageListeners.startScanning();
		if (l != null) {
			MessageEvent ev = new MessageEvent(MessageEvent.ROUTED_MESSAGE, msg, from, to, myID());
			Iterator it = l.iterator();
			while (it.hasNext()) {
				MessageListener ml = (MessageListener) it.next();
				ml.routedMessage(ev);
			}
			messageListeners.stopScanning();
		}
	}
	
	private void fireAddedBehaviour(AID agentID, Behaviour b) {
		// NOTE: A normal synchronized block could create deadlock problems
		// as it prevents concurrent scannings of the listeners list.
		List l = agentListeners.startScanning();
		if (l != null) {
			AgentEvent ev = null;
			if (b == b.root()) {
				// The behaviour has been added to the Agent
				ev = new AgentEvent(AgentEvent.ADDED_BEHAVIOUR, agentID, new BehaviourID(b), myID());
			}
			else {
				// The behaviour is actually a new child that has been added to a CompositeBehaviour
				//FIXME: TO be done
				//ev = new AgentEvent(AgentEvent.ADDED_SUB_BEHAVIOUR, agentID, new BehaviourID(b.getParent()), new BehaviourID(b), myID());
			}
			
			Iterator it = l.iterator();
			while (it.hasNext()) {
				AgentListener al = (AgentListener) it.next();
				al.addedBehaviour(ev);
			}
			agentListeners.stopScanning();
		}
	}
	
	private void fireRemovedBehaviour(AID agentID, Behaviour b) {
		// NOTE: A normal synchronized block could create deadlock problems
		// as it prevents concurrent scannings of the listeners list.
		List l = agentListeners.startScanning();
		if (l != null) {
			AgentEvent ev = new AgentEvent(AgentEvent.REMOVED_BEHAVIOUR, agentID, new BehaviourID(b), myID());
			Iterator it = l.iterator();
			while (it.hasNext()) {
				AgentListener al = (AgentListener) it.next();
				al.removedBehaviour(ev);
			}
			agentListeners.stopScanning();
		}
	}
	
	private void fireChangedBehaviourState(AID agentID, Behaviour b, String from, String to) {
		// NOTE: A normal synchronized block could create deadlock problems
		// as it prevents concurrent scannings of the listeners list.
		List l = agentListeners.startScanning();
		if (l != null) {
			AgentEvent ev = new AgentEvent(AgentEvent.CHANGED_BEHAVIOUR_STATE, agentID, new BehaviourID(b), from, to, myID());
			Iterator it = l.iterator();
			while (it.hasNext()) {
				AgentListener al = (AgentListener) it.next();
				al.changedBehaviourState(ev);
			}
			agentListeners.stopScanning();
		}
	}
	
	private void fireChangedAgentPrincipal(AID agentID, JADEPrincipal from, JADEPrincipal to) {
		// NOTE: A normal synchronized block could create deadlock problems
		// as it prevents concurrent scannings of the listeners list.
		List l = agentListeners.startScanning();
		if (l != null) {
			AgentEvent ev = new AgentEvent(AgentEvent.CHANGED_AGENT_PRINCIPAL, agentID, from, to, myID());
			Iterator it = l.iterator();
			while (it.hasNext()) {
				AgentListener al = (AgentListener) it.next();
				al.changedAgentPrincipal(ev);
			}
			agentListeners.stopScanning();
		}
	}
	
	private void fireChangedAgentState(AID agentID, AgentState from, AgentState to) {
		// NOTE: A normal synchronized block could create deadlock problems
		// as it prevents concurrent scannings of the listeners list.
		List l = agentListeners.startScanning();
		if (l != null) {
			AgentEvent ev = new AgentEvent(AgentEvent.CHANGED_AGENT_STATE, agentID, from, to, myID());
			Iterator it = l.iterator();
			while (it.hasNext()) {
				AgentListener al = (AgentListener) it.next();
				al.changedAgentState(ev);
			}
			agentListeners.stopScanning();
		}
	}
	
	private void fireBornAgent(AID agentID) {
		// NOTE: A normal synchronized block could create deadlock problems
		// as it prevents concurrent scannings of the listeners list.
		List l = containerListeners.startScanning();
		if (l != null) {
			ContainerEvent ev = new ContainerEvent(ContainerEvent.BORN_AGENT, agentID, myID());
			Iterator it = l.iterator();
			while (it.hasNext()) {
				ContainerListener cl = (ContainerListener) it.next();
				cl.bornAgent(ev);
			}
			containerListeners.stopScanning();
		}
	}
	
	private void fireDeadAgent(AID agentID) {
		// NOTE: A normal synchronized block could create deadlock problems
		// as it prevents concurrent scannings of the listeners list.
		List l = containerListeners.startScanning();
		if (l != null) {
			ContainerEvent ev = new ContainerEvent(ContainerEvent.DEAD_AGENT, agentID, myID());
			Iterator it = l.iterator();
			while (it.hasNext()) {
				ContainerListener cl = (ContainerListener) it.next();
				cl.deadAgent(ev);
			}
			containerListeners.stopScanning();
		}
	}
	
	private void fireReattached() {
		// NOTE: A normal synchronized block could create deadlock problems
		// as it prevents concurrent scannings of the listeners list.
		List l = containerListeners.startScanning();
		if (l != null) {
			ContainerEvent ev = new ContainerEvent(ContainerEvent.REATTACHED, null, myID());
			Iterator it = l.iterator();
			while (it.hasNext()) {
				ContainerListener cl = (ContainerListener) it.next();
				cl.reattached(ev);
			}
			containerListeners.stopScanning();
		}
	}
	
	
	////////////////////////////
	// Utility methods
	////////////////////////////
	private ToolNotifier findNotifier(AID observerName) {
		ToolNotifier tn = null;
		// Note that if a ToolNotifier exists it must be among the messageListeners
		// --> There is no need to search it also among the agentListeners.
		List l = messageListeners.startScanning();
		if (l != null) {
			Iterator it = l.iterator();
			while(it.hasNext()) {
				Object obj = it.next();
				if(obj instanceof ToolNotifier) {
					ToolNotifier tni = (ToolNotifier) obj;
					AID id = tni.getObserver();
					if(id.equals(observerName)) {
						tn = tni;
						break;
					}
				}
			}
			messageListeners.stopScanning();
		}
		
		// Redundant check: this condition may happen at platform shutdown
		if(tn != null && tn.getState() == Agent.AP_DELETED) { // A formerly dead notifier
			helper.deregisterMessageListener(tn);
			helper.deregisterAgentListener(tn);
			tn = null;
		}
		return tn;
	}
	
	private ContainerID myID() {
		return (ContainerID) myContainer.here();
	}	
}