platformmanagerimpl.java

java实现的P2P多agent中间件

	/**
	 * This method is invoked by the MainReplicationService when a new MainReplication slice is added
	 * and has the effect of issuing a NEW_NODE VCommand and one NEW_SLICE VCommand for each service 
	 * installed in the node hosting the new MainReplication slice. This allows services to propagate 
	 * service specific information to their new slice
	 */
	public void addMainContainerNode(NodeDescriptor dsc, Vector services) throws JADESecurityException {
		issueNewNodeCommand(dsc);
		for (int i = 0; i < services.size(); ++i) {
			ServiceDescriptor srvDsc = (ServiceDescriptor) services.get(i);
			issueNewSliceCommand(srvDsc.getService().getName(), dsc.getNode().getName());
		}
	}
	////////////////////////////////
	// Service finding methods
	////////////////////////////////
	public Service.Slice findSlice(String serviceKey, String sliceKey) throws IMTPException, ServiceException {
		ServiceEntry e = (ServiceEntry) services.get(serviceKey);

		if (e == null) {
			return null;
		} else {
			// If the special MAIN_SLICE name is used, return the local slice
			if (CaseInsensitiveString.equalsIgnoreCase(sliceKey, ServiceFinder.MAIN_SLICE)) {
				sliceKey = myIMTPManager.getLocalNode().getName();
			}

			return e.getSlice(sliceKey);
		}
	}

	public Vector findAllSlices(String serviceKey) throws IMTPException, ServiceException {
		ServiceEntry e = (ServiceEntry) services.get(serviceKey);
		if (e == null) {
			return null;
		} else {
			return e.getSlices();
		}
	}

	//////////////////////////////////////////////////////////////
	// Package-scoped methods called by the MainContainer only
	//////////////////////////////////////////////////////////////
	NodeDescriptor getDescriptor(String name) {
		return (NodeDescriptor) nodes.get(name);
	}

	/**
	 Kill all auxiliary nodes not holding any container
	 */
	void shutdown() {
		// FIXME: to be implemented
	}

	//////////////////////////////////
	// Private methods
	//////////////////////////////////
	private void issueNewNodeCommand(NodeDescriptor dsc) throws JADESecurityException {
		GenericCommand gCmd = new GenericCommand(Service.NEW_NODE, null, null);
		gCmd.addParam(dsc);
		Object result = myCommandProcessor.processIncoming(gCmd);
		if (result instanceof JADESecurityException) {
			throw (JADESecurityException) result;
		} else if (result instanceof Throwable) {
			myLogger.log(Logger.WARNING, "Unexpected error processing NEW_NODE command. Node is " + dsc.getName());
			((Throwable) result).printStackTrace();
		}
	}
	
	private void issueNewSliceCommand(String serviceName, String sliceKey) {
		GenericCommand gCmd = new GenericCommand(Service.NEW_SLICE, serviceName, null);
		gCmd.addParam(sliceKey);
		Object result = myCommandProcessor.processIncoming(gCmd);
		if (result instanceof Throwable) {
			myLogger.log(Logger.WARNING, "Unexpected error processing NEW_SLICE command. Service is " + serviceName + " node is " + sliceKey);
			((Throwable) result).printStackTrace();
		}
	}
	
	private boolean isLocalNode(Node n) {
		try {
			return myIMTPManager.getLocalNode().equals(n);
		} catch (IMTPException imtpe) {
			// Should never happen
			imtpe.printStackTrace();
			return false;
		}
	}

	private NodeDescriptor adjustDescriptor(NodeDescriptor dsc) {
		NodeDescriptor originalDsc = (NodeDescriptor) nodes.get(dsc.getName());
		if (originalDsc != null) {
			ContainerID cid = originalDsc.getContainer();
			if (cid != null) {
				dsc = new NodeDescriptor(cid, dsc.getNode());
			}
			dsc.setParentNode(originalDsc.getParentNode());
		}
		return dsc;
	}

	private List getAllNodesInfo() {
		// Get all node descriptors and build the list of NodeInfo
		Object[] allNodes = nodes.values().toArray();
		List infos = new ArrayList(allNodes.length);
		for (int i = 0; i < allNodes.length; ++i) {
			NodeDescriptor nodeDsc = (NodeDescriptor) allNodes[i];
			infos.add(new NodeInfo(nodeDsc));
		}

		// Build the map of services for each node
		Map nodeServices = new HashMap();
		// Avoid concurrent modification exception
		Object[] allServices = services.values().toArray();
		for (int j = 0; j < allServices.length; ++j) {
			ServiceEntry e = (ServiceEntry) allServices[j];
			Node[] serviceNodes = e.getNodes();

			for (int i = 0; i < serviceNodes.length; i++) {
				String nodeName = serviceNodes[i].getName();

				Vector v = (Vector) nodeServices.get(nodeName);
				if (v == null) {
					v = new Vector();
					nodeServices.put(nodeName, v);
				}
				Service svc = e.getService();
				v.addElement(new ServiceDescriptor(svc.getName(), svc));
			}
		}

		// Now fill the services in the list of NodeInfo
		Iterator it = infos.iterator();
		while (it.hasNext()) {
			NodeInfo ni = (NodeInfo) it.next();
			Vector v = (Vector) nodeServices.get(ni.getNodeDescriptor().getName());
			ni.setServices(v);
		}
		return infos;
	}

	private Node[] getChildren(String name) {
		List children = new ArrayList();
		Object[] allNodes = nodes.values().toArray();
		for (int i = 0; i < allNodes.length; i++) {
			NodeDescriptor dsc = (NodeDescriptor) allNodes[i];
			Node parent = dsc.getParentNode();
			if (parent != null && name.equals(parent.getName())) {
				children.add(dsc.getNode());
			}
		}
		Node[] childrenArray = new Node[children.size()];
		for (int i = 0; i < childrenArray.length; ++i) {
			childrenArray[i] = (Node) children.get(i);
		}
		return childrenArray;
	}

	private void adjustName(NodeDescriptor dsc, Node node) {
		ContainerID cid = dsc.getContainer();
		if (cid != null) {
			// If the node hosts a container, use the container naming convention
			adjustContainerName(node, cid);
			node.setName(cid.getName());
			dsc.setName(cid.getName());
		} else {
			// Otherwise use the node naming convention unless a custom name is specified
			if (node.getName() == null || node.getName().equals(NO_NAME)) {
				String name = null;
				NodeDescriptor old = null;
				do {
					name = AUX_NODE_NAME + '-' + nodeNo;
					nodeNo++;
					old = (NodeDescriptor) nodes.get(name);
				} while (old != null);
				node.setName(name);
			}
			dsc.setName(node.getName());
		}
	}

	private void adjustContainerName(Node n, ContainerID cid) {
		String name = null;
		NodeDescriptor old = null;
		if (n.hasPlatformManager()) {
			cid.setMain(new Boolean(true));
		}else{
			cid.setMain(new Boolean(false));
		}
		
		if (cid.getName() == null || cid.getName().equals(NO_NAME)) {
			if (n.hasPlatformManager()) {
				// Use the Main-Container-<N> name schema
				do {
					name = AgentContainer.MAIN_CONTAINER_NAME + (mainContainerNo == 0 ? "" : "-" + mainContainerNo);
					mainContainerNo++;
					old = (NodeDescriptor) nodes.get(name);
					
				} while (old != null);
			} else {
				do {
					name = AgentContainer.AUX_CONTAINER_NAME + '-' + containerNo;
					containerNo++;
					old = (NodeDescriptor) nodes.get(name);
				} while (old != null);
			}
			cid.setName(name);
		} else {
			// The new container comes with a user defined name.
			// If it is already in use add a progressive number
			
			name = cid.getName();
			int cnt = 1;
			old = (NodeDescriptor) nodes.get(name);
			while (old != null) {
				name = cid.getName() + '-' + cnt;
				cnt++;
				old = (NodeDescriptor) nodes.get(name);
			}
			cid.setName(name);
			
		}
	}

	private void monitor(NodeDescriptor dsc) {
		boolean needMonitor = true;
		Node node = dsc.getNode();
		Node parent = dsc.getParentNode();
		if (parent != null) {
			// This is a child node --> Do not monitor it directly if the parent is already monitored or is the local node
			if (isLocalNode(parent)) {
				needMonitor = false;
			}
			else {
				NodeFailureMonitor failureMonitor = (NodeFailureMonitor) monitors.get(parent.getName());
				if (failureMonitor != null) {
					failureMonitor.addChild(node);
					if (myLogger.isLoggable(Logger.CONFIG)) {
						myLogger.log(Logger.INFO, "Node <" + node.getName() + "> added as child of node " + parent.getName());
					}
					needMonitor = false;
				}
			}
		}
		if (needMonitor) {
			monitor(node);
		}
	}

	private NodeFailureMonitor monitor(Node target) {

		NodeEventListener listener = new NodeEventListener() {

			public void nodeAdded(Node n) {
				myLogger.log(Logger.INFO, "--- Node <" + n.getName() + "> ALIVE ---");
			}

			public void nodeRemoved(Node n) {
				removeTerminatedNode(n);
			}

			public void nodeUnreachable(Node n) {
				myLogger.log(Logger.WARNING, "--- Node <" + n.getName() + "> UNREACHABLE ---");
			}

			public void nodeReachable(Node n) {
				myLogger.log(Logger.INFO, "--- Node <" + n.getName() + "> REACHABLE ---");
			}

		};

		// Start a new node failure monitor
		NodeFailureMonitor failureMonitor = NodeFailureMonitor.getFailureMonitor();
		failureMonitor.start(target, listener);
		monitors.put(target.getName(), failureMonitor);

		return failureMonitor;
	}

	private void removeTerminatedNode(Node n) {
		if (myLogger.isLoggable(Logger.INFO)) {
			myLogger.log(Logger.INFO, "--- Node <" + n.getName() + "> TERMINATED ---");
		}

		try {
			removeNode(new NodeDescriptor(n), false);
		} catch (IMTPException imtpe) {
			// Should never happen since this is a local call
			imtpe.printStackTrace();
		} catch (ServiceException se) {
			// There is nothing we can do
			se.printStackTrace();
		}
	}

	/**
	 Inner class NodeInfo.
	 Embeds the node descriptor and the services currently installed
	 on the node
	 */
	private class NodeInfo {
		private NodeDescriptor nodeDsc;

		private Vector services;

		private NodeInfo(NodeDescriptor nd) {
			nodeDsc = nd;
		}

		public NodeDescriptor getNodeDescriptor() {
			return nodeDsc;
		}

		public Vector getServices() {
			return services;
		}

		public void setServices(Vector ss) {
			services = ss;
		}
	} // END of inner class NodeInfo
	
	
	// For debugging purpose only
	Map getServicesMap() {
		return services;
	}

}