Missing file

2 files changed, 517 insertions, 0 deletions

diff --git a/java/src/IceGrid/TreeNode/Nodes.java b/java/src/IceGrid/TreeNode/Nodes.java
new file mode 100755
index 00000000000..d8aa6a9c644
--- /dev/null
+++ b/java/src/IceGrid/TreeNode/Nodes.java
@@ -0,0 +1,153 @@
+// **********************************************************************

+//

+// Copyright (c) 2003-2005 ZeroC, Inc. All rights reserved.

+//

+// This copy of Ice is licensed to you under the terms described in the

+// ICE_LICENSE file included in this distribution.

+//

+// **********************************************************************

+package IceGrid.TreeNode;

+

+import IceGrid.ApplicationDescriptor;

+import IceGrid.NodeDescriptor;

+import IceGrid.TreeModelI;

+import IceGrid.Model;

+import IceGrid.NodeDescriptor;

+import IceGrid.NodeDynamicInfo;

+import IceGrid.NodeUpdateDescriptor;

+import IceGrid.ServerDynamicInfo;

+import IceGrid.AdapterDynamicInfo;

+import IceGrid.ServerState;

+

+public class Nodes extends Parent

+{

+    public Nodes(java.util.Map nodeMap, Application application)

+    {

+	super("Nodes", application.getModel());

+	_descriptors = nodeMap;

+

+	java.util.Iterator p = nodeMap.entrySet().iterator();

+	while(p.hasNext())

+	{

+	    java.util.Map.Entry entry = (java.util.Map.Entry)p.next();

+	    String nodeName = (String)entry.getKey();

+	    NodeDescriptor nodeDescriptor = (NodeDescriptor)entry.getValue();

+	    addChild(new Node(nodeName, nodeDescriptor, application));

+	}

+	

+	//

+	// Also create a Node for each node that is up

+	//

+	Root root = _model.getRoot();

+	p = root.getNodesUp().iterator();

+	while(p.hasNext())

+	{

+	    String nodeName = (String)p.next();

+	    if(findChild(nodeName) == null)

+	    {

+		addChild(new Node(nodeName, application.getModel()));

+	    }

+	}

+    }

+   

+    void update(java.util.List updates, String[] removeNodes)

+    {

+	Application application = (Application)getParent();

+

+	//

+	// Note: _descriptors has already the nodes removed but

+	// needs to get the updated and new NodeDescriptors

+	//

+

+	//

+	// One big set of removes

+	//

+	removeChildren(removeNodes);

+	

+	//

+	// One big set of updates, followed by inserts

+	//

+	java.util.Vector newChildren = new java.util.Vector();

+	

+	java.util.Iterator p = updates.iterator();

+	while(p.hasNext())

+	{

+	    NodeUpdateDescriptor update = (NodeUpdateDescriptor)p.next();

+	    Node node = findNode(update.name);

+	    if(node == null)

+	    {

+		NodeDescriptor nodeDescriptor = new NodeDescriptor(update.variables,

+								   update.serverInstances,

+								   update.servers);

+		_descriptors.put(update.name, nodeDescriptor);

+		node = new Node(update.name, nodeDescriptor, application);

+		newChildren.add(node);

+	    }

+	    else

+	    {

+		NodeDescriptor nodeDescriptor = node.update(update, application);

+		if(nodeDescriptor != null)

+		{

+		    _descriptors.put(update.name, nodeDescriptor);

+		}

+	    }

+	}

+	

+	addChildren((CommonBaseI[])newChildren.toArray(new CommonBaseI[0]));

+	p = newChildren.iterator();

+	while(p.hasNext())

+	{

+	    ServerTemplate serverTemplate = (ServerTemplate)p.next();

+	    serverTemplate.setParent(this);

+	}

+    }

+

+    void nodeUp(String nodeName)

+    {

+	Node node = findNode(nodeName);

+	if(node == null)

+	{

+	    node = new Node(nodeName, _model);

+	    addChild(node, true);

+	}

+	else

+	{

+	    node.up();

+	}

+    }

+

+    void nodeDown(String nodeName)

+    {

+	//

+	// We remove nodes that are down and without descriptor

+	//

+	Node node = findNode(nodeName);

+	if(node != null)

+	{

+	    if(node.down())

+	    {

+		removeChild(nodeName, true);

+	    }

+	}

+	//

+	// Else log a warning?

+	//

+    }

+    

+    public void cleanup()

+    {

+	java.util.Iterator p = _children.iterator();

+	while(p.hasNext())

+	{

+	    Node node = (Node)p.next();

+	    node.cleanup();

+	}

+    }

+

+    Node findNode(String nodeName)

+    {

+	return (Node)findChild(nodeName);

+    }

+

+    private java.util.Map _descriptors;

+}

diff --git a/java/src/IceGrid/TreeNode/Root.java b/java/src/IceGrid/TreeNode/Root.java
new file mode 100755
index 00000000000..7634e71f4d5
--- /dev/null
+++ b/java/src/IceGrid/TreeNode/Root.java
@@ -0,0 +1,364 @@
+// **********************************************************************

+//

+// Copyright (c) 2003-2005 ZeroC, Inc. All rights reserved.

+//

+// This copy of Ice is licensed to you under the terms described in the

+// ICE_LICENSE file included in this distribution.

+//

+// **********************************************************************

+package IceGrid.TreeNode;

+

+import IceGrid.AdapterDynamicInfo;

+import IceGrid.ApplicationDescriptor;

+import IceGrid.ApplicationUpdateDescriptor;

+import IceGrid.Model;

+import IceGrid.NodeDynamicInfo;

+import IceGrid.ServerDynamicInfo;

+import IceGrid.ServerState;

+import IceGrid.TreeModelI;

+

+

+public class Root extends Parent

+{

+    static class AdapterInstanceId

+    {

+	AdapterInstanceId(String serverId, String adapterId)

+	{

+	    this.serverId = serverId;

+	    this.adapterId = adapterId;

+	}

+

+	public boolean equals(Object obj)

+	{

+	    try

+	    {

+		AdapterInstanceId other = (AdapterInstanceId)obj;

+		return serverId.equals(other.serverId) 

+		    && adapterId.equals(other.adapterId);

+	    }

+	    catch(ClassCastException e)

+	    {

+		return false;

+	    }

+	}

+	

+	public int hashCode()

+	{

+	    return serverId.hashCode() ^ adapterId.hashCode();

+	}

+	

+	String serverId;

+	String adapterId;

+    };

+

+    static class DynamicInfo

+    {

+	//

+	// ServerId to ServerDynamicInfo

+	//

+	java.util.Map serverInfoMap = new java.util.HashMap();

+

+	//

+	// AdapterInstanceId to Ice.ObjectPrx

+	//

+	java.util.Map adapterInfoMap = new java.util.HashMap();

+    };

+

+

+    public Root(Model model)

+    {

+	super("Applications", model, true);

+    }

+

+    public void init(java.util.List descriptors)

+    {

+	assert(_children.size() == 0);

+	

+	java.util.Iterator p = descriptors.iterator();

+	while(p.hasNext())

+	{

+	    ApplicationDescriptor descriptor = (ApplicationDescriptor)p.next();

+	    Application child = new Application(descriptor, _model);

+	    addChild(child);

+	    child.setParent(this);

+	}

+	fireStructureChangedEvent(this);

+	expandChildren();

+    }

+    

+    public void clear()

+    {

+	clearChildren();

+	fireStructureChangedEvent(this);

+    }

+

+    public void applicationAdded(ApplicationDescriptor desc)

+    {

+	Application child = new Application(desc, _model); 

+	child.setParent(this);

+	addChild(child, true);

+	expandChildren();

+    }

+ 

+    public void applicationRemoved(String name)

+    {

+	Application application = (Application)findChild(name);

+	removeChild(name, true);

+    }

+    

+    public void applicationUpdated(ApplicationUpdateDescriptor desc)

+    {

+	Application application = (Application)findChild(desc.name);

+	application.update(desc);

+	expandChildren();

+    }

+

+    public void nodeUp(NodeDynamicInfo updatedInfo)

+    {

+	String nodeName = updatedInfo.name;

+

+	DynamicInfo info = new DynamicInfo();

+	_dynamicInfoMap.put(nodeName, info);

+

+	for(int i = 0; i < updatedInfo.servers.length; ++i)

+	{

+	    assert(updatedInfo.servers[i].state != ServerState.Destroyed);

+	    assert(updatedInfo.servers[i].state != ServerState.Inactive);

+	    info.serverInfoMap.put(updatedInfo.servers[i].id, updatedInfo.servers[i]);

+	}

+	

+	//

+	// Need to tell *every* server on this node

+	//

+	java.util.List serverList = (java.util.List)_nodeServerMap.get(nodeName);

+	if(serverList != null)

+	{

+	    java.util.Iterator p = serverList.iterator();

+	    while(p.hasNext())

+	    {

+		Server server = (Server)p.next();

+		ServerDynamicInfo serverInfo = (ServerDynamicInfo)info.

+		    serverInfoMap.get(server.getId());

+		if(serverInfo == null)

+		{

+		    server.updateDynamicInfo(ServerState.Inactive, 0);

+		}

+		else

+		{

+		    server.updateDynamicInfo(serverInfo.state, serverInfo.pid);

+		}

+	    }

+	}

+

+	for(int i = 0; i < updatedInfo.adapters.length; ++i)

+	{

+	    AdapterInstanceId instanceId = new AdapterInstanceId(

+		"" /* updatedInfo.adapters[i].serverId */, updatedInfo.adapters[i].id);

+

+	    info.adapterInfoMap.put(instanceId, updatedInfo.adapters[i].proxy);

+

+	    Adapter adapter = (Adapter)_adapterMap.get(instanceId);

+	    if(adapter != null)

+	    {

+		adapter.updateProxy(updatedInfo.adapters[i].proxy);

+	    }

+	}

+

+	java.util.Iterator p = _children.iterator();

+	while(p.hasNext())

+	{

+	    Application application = (Application)p.next();

+	    application.nodeUp(nodeName);

+	}

+    }

+

+    public void nodeDown(String nodeName)

+    {

+	_dynamicInfoMap.remove(nodeName);

+

+	java.util.Iterator p = _children.iterator();

+	while(p.hasNext())

+	{

+	    Application application = (Application)p.next();

+	    application.nodeDown(nodeName);

+	}

+

+	java.util.List serverList = (java.util.List)_nodeServerMap.get(nodeName);

+	if(serverList != null)

+	{

+	    while(p.hasNext())

+	    {

+		Server server = (Server)p.next();

+		server.updateDynamicInfo(null, 0);

+	    }

+	}

+

+	java.util.List adapterList = (java.util.List)_nodeAdapterMap.get(nodeName);

+	if(adapterList != null)

+	{

+	    while(p.hasNext())

+	    {

+	        Adapter adapter = (Adapter)p.next();

+		adapter.updateProxy(null);

+	    }

+	}

+    }

+

+    public java.util.Set getNodesUp()

+    {

+	return _dynamicInfoMap.keySet();

+    }

+

+    public void updateServer(String nodeName, ServerDynamicInfo updatedInfo)

+    {

+	//

+	// This node must be up

+	//

+	DynamicInfo info = (DynamicInfo)_dynamicInfoMap.get(nodeName);

+	assert info != null;

+	info.serverInfoMap.put(updatedInfo.id, updatedInfo);

+	

+	//

+	// Is a corresponding Server registered?

+	//

+	Server server = (Server)_serverMap.get(updatedInfo.id);

+	if(server != null)

+	{

+	    server.updateDynamicInfo(updatedInfo.state, updatedInfo.pid);

+	}

+    }

+

+    public void updateAdapter(String nodeName, AdapterDynamicInfo updatedInfo)

+    {

+	//

+	// This node must be up

+	//

+	DynamicInfo info = (DynamicInfo)_dynamicInfoMap.get(nodeName);

+	assert info != null;

+	AdapterInstanceId instanceId 

+	    = new AdapterInstanceId("" /* updatedInfo.serverId */, updatedInfo.id);

+	info.adapterInfoMap.put(instanceId, updatedInfo.proxy);

+	

+	//

+	// Is a corresponding Adapter registered?

+	//

+	Adapter adapter = (Adapter)_adapterMap.get(instanceId);

+	if(adapter != null)

+	{

+	    adapter.updateProxy(updatedInfo.proxy);

+	}

+    }

+    

+    Ice.ObjectPrx registerAdapter(String nodeName, String serverId, String adapterId,

+				  Adapter adapter)

+    {

+	AdapterInstanceId instanceId = new AdapterInstanceId(serverId, adapterId);

+

+	_adapterMap.put(instanceId, adapter);

+	

+	java.util.List adapterList = (java.util.List)_nodeAdapterMap.get(nodeName);

+	if(adapterList == null)

+	{

+	    adapterList = new java.util.LinkedList();

+	    _nodeAdapterMap.put(nodeName, adapterList);

+	}

+	adapterList.add(adapter);

+	

+	DynamicInfo info = (DynamicInfo)_dynamicInfoMap.get(nodeName);

+	if(info == null)

+	{

+	    // Node is down

+	    return null;

+	}

+	else

+	{

+	    return (Ice.ObjectPrx)info.adapterInfoMap.get(instanceId);

+	}

+    }

+    

+    void unregisterAdapter(String nodeName, String serverId, String adapterId, 

+			   Adapter adapter)

+    {

+	AdapterInstanceId instanceId = new AdapterInstanceId(serverId, adapterId);

+	_adapterMap.remove(instanceId);

+

+	java.util.List adapterList = (java.util.List)_nodeAdapterMap.get(nodeName);

+	if(adapterList != null)

+	{

+	    adapterList.remove(adapter);

+	}

+    }

+

+    ServerState registerServer(String nodeName, String serverId, Server server,

+			       Ice.IntHolder pid)

+    {

+	_serverMap.put(serverId, server);

+	

+	java.util.List serverList = (java.util.List)_nodeServerMap.get(nodeName);

+	if(serverList == null)

+	{

+	    serverList = new java.util.LinkedList();

+	    _nodeServerMap.put(nodeName, serverList);

+	}

+	serverList.add(server);

+

+	DynamicInfo info = (DynamicInfo)_dynamicInfoMap.get(nodeName);

+	if(info == null)

+	{	

+	    // Node is down

+	    pid.value = 0;

+	    return null;

+	}

+	else

+	{

+	    ServerDynamicInfo serverInfo = (ServerDynamicInfo)info.

+		serverInfoMap.get(serverId);

+	    if(serverInfo == null)

+	    {

+		pid.value = 0;

+		return ServerState.Inactive;

+	    }

+	    else

+	    {

+		pid.value = serverInfo.pid;

+		return serverInfo.state;

+	    }

+	}

+    }

+    

+    void unregisterServer(String nodeName, String serverId, Server server)

+    {

+	_serverMap.remove(serverId);

+	java.util.List serverList = (java.util.List)_nodeServerMap.get(nodeName);

+	if(serverList != null)

+	{

+	    serverList.remove(server);

+	}

+    }

+

+    

+    //

+    // Nodename to DynamicInfo

+    //

+    private java.util.Map _dynamicInfoMap = new java.util.HashMap();

+

+    //

+    // AdapterInstanceId to Adapter

+    //

+    private java.util.Map _adapterMap = new java.util.HashMap();

+

+    //

+    // Nodename to list of Adapter (used when a node goes down)

+    //

+    private java.util.Map _nodeAdapterMap = new java.util.HashMap();

+

+    //

+    // ServerId to Server

+    //

+    private java.util.Map _serverMap = new java.util.HashMap();

+

+    //

+    // Nodename to list of Server (used when a node goes down)

+    //

+    private java.util.Map _nodeServerMap = new java.util.HashMap();

+}