agenttree.java

java实现的P2P多agent中间件

	/**
	 * @deprecated Use addContainerNode(String, InetAddress) instead
	 */
	public void addContainerNode(ContainerNode node, String typeContainer, InetAddress addr) {
		AgentTreeModel model = getModel();
		MutableTreeNode root = (MutableTreeNode) model.getRoot();
		node.setType(typeContainer);
		Enumeration folders = root.children();
		while (folders.hasMoreElements()) {
			AgentTree.Node folderNode = (AgentTree.Node) folders.nextElement();
			String folderName = folderNode.getName();
			if (folderName.equalsIgnoreCase(localPlatformName)) {
				model.insertNodeInto(node, folderNode, folderNode.getChildCount());
				break;
			}
		}
		node.setAddress(addr);
	}

	public void removeContainerNode(String nameNode) {
		AgentTreeModel model = getModel();
		MutableTreeNode root = (MutableTreeNode) model.getRoot();
		Enumeration folders = root.children();
		while (folders.hasMoreElements()) {
			AgentTree.Node folderNode = (AgentTree.Node) folders.nextElement();
			String folderName = folderNode.getName();
			if (folderName.equalsIgnoreCase(localPlatformName)) {//found the localplatform folder	
				Enumeration containers = folderNode.children();
				while (containers.hasMoreElements()) {
					AgentTree.Node node = (AgentTree.Node) containers.nextElement();
					String nodeName = node.getName();
					if (nodeName.equalsIgnoreCase(nameNode)) {
						model.removeNodeFromParent(node);
						return;
					}
				}
			}
		}
	}

	public void addRemotePlatformsFolderNode() {
		AgentTreeModel model = getModel();
		MutableTreeNode root = (MutableTreeNode) model.getRoot();
		Enumeration children = root.children();

		boolean existing = false;

		while (children.hasMoreElements() & (!existing)) {
			AgentTree.Node node = (AgentTree.Node) children.nextElement();
			String nodeName = node.getName();
			if (nodeName.equalsIgnoreCase(REMOTE_PLATFORMS_FOLDER_NAME))
				existing = true;
		}

		if (!existing) {
			RemotePlatformsFolderNode rpn = new RemotePlatformsFolderNode(REMOTE_PLATFORMS_FOLDER_NAME);
			model.insertNodeInto(rpn, root, root.getChildCount());
		}

		return;
	}

	public void addAgentNode(String agentName, String agentAddress, String containerName) {
		addAgentNode(agentName, agentAddress, containerName, "Running", null);
	}
	
	public void addAgentNode(String agentName, String agentAddress, String containerName, String agentState, String ownership) {
		AgentNode node = new AgentNode(agentName);
		node.setAddress(agentAddress);
		node.setState(agentState);
		node.setOwnership(ownership);
		
		AgentTreeModel model = getModel();
		MutableTreeNode root = (MutableTreeNode) model.getRoot();
		
		// Search for the folder of the local Platform
		Enumeration folders = root.children();
		while (folders.hasMoreElements()) {
			Node folderNode = (Node) folders.nextElement();
			String folderName = folderNode.getName();
			if (folderName.equalsIgnoreCase(localPlatformName)) {
				// Search for the agent container 'containerName'
				Enumeration containers = folderNode.children();
				while (containers.hasMoreElements()) {
					Node containerNode = (Node) containers.nextElement();
					String contName = containerNode.getName();
					if (contName.equalsIgnoreCase(containerName)) {
						// Add this new agent to this container and return
						int position = getPosition(node, containerNode);
						model.insertNodeInto(node, containerNode, position); 
						return;
					}
				}
			}
		}
	}
	
	private int getPosition(Node node, Node containerNode) {
		int size = containerNode.getChildCount();
		if (size == 0) {
			// This is the first child
			return 0;
		}
		else {
			int k = node.compareTo((Node) containerNode.getChildAt(0));
			if (k < 0) {
				// Insert new child at the beginning of the list
				return 0;
			}
			else {
				k = node.compareTo((Node) containerNode.getChildAt(size-1));
				if (k >= 0) {
					// Insert new child at the end of the list
					return size;
				}
				else {
					// Insert new child "somewhere" in the list
					return getPosition(node, containerNode, 0, size-1);
				}
			}
		}
	}
	
	private int getPosition(Node node, Node containerNode, int down, int up) {
		if ((up - down) == 1) {
			return up;
		}
		else {
			int middle = (up + down) / 2;
			int k = node.compareTo((Node) containerNode.getChildAt(middle)); 
			if (k == 0) {
				return middle+1;
			}
			else if (k < 0) {
				return getPosition(node, containerNode, down, middle);
			}
			else {
				return getPosition(node, containerNode, middle, up);
			}
		}
	}
	
	/**
	 * @deprecated Use addAgentNode(String, String, String) instead
	 */
	public void addAgentNode(AgentNode node, String containerName, String agentName, String agentAddress, String agentType) {
		AgentTreeModel model = getModel();
		MutableTreeNode root = (MutableTreeNode) model.getRoot();
		node.setType(agentType);
		AgentTree.AgentNode nod = (AgentTree.AgentNode) node;
		nod.setAddress(agentAddress);
		nod.setState("Running");
		//search for the folder of the local Platform
		Enumeration folders = root.children();
		while (folders.hasMoreElements()) {
			AgentTree.Node folderNode = (AgentTree.Node) folders.nextElement();
			String folderName = folderNode.getName();
			if (folderName.equalsIgnoreCase(localPlatformName)) {
				// Search for the agent container 'containerName'
				Enumeration containers = folderNode.children();
				while (containers.hasMoreElements()) {
					AgentTree.Node container = (AgentTree.Node) containers.nextElement();
					String contName = container.getName();
					if (contName.equalsIgnoreCase(containerName)) {
						// Add this new agent to this container and return
						model.insertNodeInto(node, container, container.getChildCount());
						return;
					}
				}
			}
		}
	}

	public void modifyAgentNode(String containerName, String agentName, String address, String state, String ownership) {
		AgentTreeModel model = getModel();
		MutableTreeNode root = (MutableTreeNode) model.getRoot();
		//search for the folder of the local Platform
		Enumeration folders = root.children();
		while (folders.hasMoreElements()) {
			AgentTree.Node folderNode = (AgentTree.Node) folders.nextElement();
			String folderName = folderNode.getName();
			if (folderName.equalsIgnoreCase(localPlatformName)) {
				// Search for the agent container 'containerName'
				Enumeration containers = folderNode.children();
				while (containers.hasMoreElements()) {
					AgentTree.Node container = (AgentTree.Node) containers.nextElement();
					String contName = container.getName();
					if (contName.equalsIgnoreCase(containerName)) {
						Enumeration agents = container.children();
						while (agents.hasMoreElements()) {
							AgentTree.Node agent = (AgentTree.Node) agents.nextElement();

							if (agent.getName().equalsIgnoreCase(agentName)) {
								if (state != null)
									agent.setState(state);
								if (ownership != null)
									agent.setOwnership(ownership);
								agent.changeIcon(state);
								model.nodeChanged(agent);
								return;
							}
						}
					}
				}
			}
		}
	}

	public void moveAgentNode(String fromContainerName, String toContainerName, String agentName) {
		AgentTreeModel model = getModel();
		AgentTree.Node fromContainer = findContainerNode(fromContainerName);
		AgentTree.Node toContainer = findContainerNode(toContainerName);

		// If there is a frozen agent already, do nothing, else move the agent node
		AgentTree.Node frozenAgents = findFrozenAgentsFolder(toContainer, FROZEN_AGENTS_FOLDER_NAME);
		if (frozenAgents != null) {
			AgentTree.Node agent = findAgentNode(frozenAgents, agentName);
			if (agent == null) {
				// Move the agent node
				agent = findAgentNode(fromContainer, agentName);
				model.removeNodeFromParent(agent);
				model.insertNodeInto(agent, toContainer, toContainer.getChildCount());
			}
		} 
		else {
			// Move the agent node
			AgentTree.Node agent = findAgentNode(fromContainer, agentName);
			model.removeNodeFromParent(agent);
			model.insertNodeInto(agent, toContainer, toContainer.getChildCount());
		}
	}

	public void freezeAgentNode(String oldContainerName, String newContainerName, String agentName) {
		AgentTreeModel model = getModel();
		AgentTree.Node oldContainer = findContainerNode(oldContainerName);
		AgentTree.Node agent = findAgentNode(oldContainer, agentName);
		model.removeNodeFromParent(agent);

		agent.setState("frozen");
		agent.changeIcon("frozen");

		AgentTree.Node newContainer = findContainerNode(newContainerName);
		AgentTree.Node frozenAgents = findFrozenAgentsFolder(newContainer, FROZEN_AGENTS_FOLDER_NAME);
		if (frozenAgents == null) {
			frozenAgents = createContainerNode(FROZEN_AGENTS_FOLDER_NAME);
			frozenAgents.setType(FROZEN_CONTAINER_TYPE);
			model.insertNodeInto(frozenAgents, newContainer, 0);
		}
		model.insertNodeInto(agent, frozenAgents, frozenAgents.getChildCount());

	}

	public void thawAgentNode(String oldContainerName, String newContainerName, String agentName) {
		AgentTreeModel model = getModel();
		AgentTree.Node oldContainer = findContainerNode(oldContainerName);
		AgentTree.Node frozenAgents = findFrozenAgentsFolder(oldContainer, FROZEN_AGENTS_FOLDER_NAME);
		AgentTree.Node agent = findAgentNode(frozenAgents, agentName);
		model.removeNodeFromParent(agent);
		if (frozenAgents.isLeaf()) {
			model.removeNodeFromParent(frozenAgents);
		}

		agent.setState("active");
		agent.changeIcon("active");

		AgentTree.Node newContainer = findContainerNode(newContainerName);
		model.insertNodeInto(agent, newContainer, newContainer.getChildCount());

	}

	public void removeAgentNode(String containerName, String agentName) {
		AgentTreeModel model = getModel();
		AgentTree.Node container = findContainerNode(containerName);
		if (container != null) {
			AgentTree.Node agent = findAgentNode(container, agentName);

			if (agent != null) {
				model.removeNodeFromParent(agent);
			} else {
				// It can be a frozen agent
				AgentTree.Node frozenAgents = findFrozenAgentsFolder(container, FROZEN_AGENTS_FOLDER_NAME);
				if (frozenAgents != null) {
					agent = findAgentNode(frozenAgents, agentName);

					model.removeNodeFromParent(agent);
					if (frozenAgents.isLeaf()) {
						model.removeNodeFromParent(frozenAgents);
					}
				}
			}
		}
	}

	public void addRemotePlatformNode(AID ams, APDescription desc) {

		AgentTreeModel model = getModel();
		MutableTreeNode root = (MutableTreeNode) model.getRoot();

		// Search for the folder REMOTEPLATFORM
		Enumeration containers = root.children();
		while (containers.hasMoreElements()) {//1
			AgentTree.Node container = (AgentTree.Node) containers.nextElement();
			String contName = container.getName();
			if (contName.equalsIgnoreCase(REMOTE_PLATFORMS_FOLDER_NAME)) {//2
				boolean found = false;
				Enumeration agents = container.children();
				while (agents.hasMoreElements() && !found) {//3
					AgentTree.RemotePlatformNode platform = (AgentTree.RemotePlatformNode) agents.nextElement();
					String APName = platform.getName();
					if (APName.equalsIgnoreCase(desc.getName())) {//update the APDescription of this node
						platform.setAPDescription(desc);
						found = true;
					}
				}//3
				if (!found) {
					// Add this new platform to this container and return
					RemotePlatformNode node = new RemotePlatformNode(desc.getName());
					node.setAPDescription(desc);
					node.setAmsAID(ams);
					model.insertNodeInto(node, container, container.getChildCount());
				}
				return;
			}//2
		}//1
	}

	public void removeRemotePlatformNode(String name) {
		AgentTreeModel model = getModel();
		MutableTreeNode root = (MutableTreeNode) model.getRoot();

		// Search for the  RemotePlatforms node
		Enumeration containers = root.children();
		while (containers.hasMoreElements()) {
			AgentTree.Node container = (AgentTree.Node) containers.nextElement();
			String contName = container.getName();
			if (contName.equalsIgnoreCase(REMOTE_PLATFORMS_FOLDER_NAME)) {
				// Search for the ams  
				Enumeration agents = container.children();
				while (agents.hasMoreElements()) {
					AgentTree.Node agent = (AgentTree.Node) agents.nextElement();
					String agName = agent.getName();
					if (agName.equalsIgnoreCase(name)) {
						model.removeNodeFromParent(agent);
						//if it's the last child remove the folder REMOTEPLATFORMS
						if (container.getChildCount() == 0)
							model.removeNodeFromParent(container);
						return;
					}
				}
			}
		}
	}

	public void addRemoteAgentNode(AMSAgentDescription agent, String HAP) {

		AgentTreeModel model = getModel();
		MutableTreeNode root = (MutableTreeNode) model.getRoot();

		//Search for the REMOTEPLATFORMS node
		Enumeration containers = root.children();

		while (containers.hasMoreElements()) { 

			AgentTree.Node container = (AgentTree.Node) containers.nextElement();
			String contName = container.getName();

			if (contName.equalsIgnoreCase(REMOTE_PLATFORMS_FOLDER_NAME)) { 
				//search the remotePlatform
				Enumeration plat_Enum = container.children();

				while (plat_Enum.hasMoreElements()) {
					AgentTree.Node platformNode = (AgentTree.Node) plat_Enum.nextElement();
					String platformNodeName = platformNode.getName();
					if (platformNodeName.equalsIgnoreCase(HAP)) {
						//now add remote agent registered with that ams...
						Enumeration remote_agents = platformNode.children();
						boolean found = false;
						while (remote_agents.hasMoreElements() && !found) { 

							AgentTree.RemoteAgentNode node = (AgentTree.RemoteAgentNode) remote_agents.nextElement();
							String remoteName = node.getName();
							if (remoteName.equalsIgnoreCase(agent.getName().getName())) {
								node.setAMSDescription(agent); //update the AMSDescription
								found = true;
							}
						}
						if (!found) {
							AgentTree.RemoteAgentNode newNode = new AgentTree.RemoteAgentNode(agent.getName().getName());
							newNode.setAMSDescription(agent);
							model.insertNodeInto(newNode, platformNode, platformNode.getChildCount());
						}
					}
				}
			}
		}
	}

	public Node getSelectedNode() {
		TreePath path = tree.getSelectionPath();
		if (path != null) {
			return (Node) path.getLastPathComponent();
		} else {
			return null;
		}
	}

	public AgentTreeModel getModel() {
		if (tree.getModel() instanceof AgentTreeModel)
			return (AgentTreeModel) tree.getModel();
		else {
			System.out.println(tree.getModel());
			return null;
		}
	}

	public void register(String key, JPopupMenu popmenu, String pathImage) {
		NodeDescriptor nDescriptor = new NodeDescriptor(popmenu, pathImage);
		mapDescriptor.put(key, nDescriptor);
	}

	public JPopupMenu getPopupMenu(String key) {
		NodeDescriptor nDescriptor = (NodeDescriptor) mapDescriptor.get(key);
		return nDescriptor.getPopupMenu();
	}

	public void setNewPopupMenu(String key, JPopupMenu pop) {
		if (mapDescriptor.containsKey(key)) {
			NodeDescriptor nDescriptor = (NodeDescriptor) mapDescriptor.get(key);
			nDescriptor.setNewPopupMenu(pop);
		}
	}

	protected String getIconAgent(String key) {
		NodeDescriptor nDescriptor = (NodeDescriptor) mapDescriptor.get(key);
		return nDescriptor.getPathImage();
	}

	private AgentTree.Node findAgentNode(AgentTree.Node container, String name) {

		Enumeration agents = container.children();
		while (agents.hasMoreElements()) {
			AgentTree.Node agent = (AgentTree.Node) agents.nextElement();
			if (agent.getName().equalsIgnoreCase(name)) {
				return agent;
			}
		}

		return null;
	}

	private AgentTree.Node findContainerNode(String name) {
		AgentTreeModel model = getModel();
		MutableTreeNode root = (MutableTreeNode) model.getRoot();
		//search for the folder of the local Platform
		Enumeration folders = root.children();
		while (folders.hasMoreElements()) {
			AgentTree.Node folderNode = (AgentTree.Node) folders.nextElement();
			String folderName = folderNode.getName();
			if (folderName.equalsIgnoreCase(localPlatformName)) {
				// Search for the agent container 'name'
				Enumeration containers = folderNode.children();
				while (containers.hasMoreElements()) {
					AgentTree.Node container = (AgentTree.Node) containers.nextElement();
					String contName = container.getName();
					if (contName.equalsIgnoreCase(name)) {
						return container;
					}
				}
			}
		}

		return null;

	}

	private AgentTree.Node findFrozenAgentsFolder(AgentTree.Node container, String name) {
		Enumeration agents = container.children();
		while (agents.hasMoreElements()) {
			AgentTree.Node child = (AgentTree.Node) agents.nextElement();
			if (child.getName().equalsIgnoreCase(name) && child.getType().equalsIgnoreCase(FROZEN_CONTAINER_TYPE)) {
				return child;
			}
		}

		return null;
	}
}