IceGrid GUI refactoring

1 files changed, 767 insertions, 0 deletions

diff --git a/java/src/IceGridGUI/LiveDeployment/Node.java b/java/src/IceGridGUI/LiveDeployment/Node.java
new file mode 100755
index 00000000000..dbd8d2a3114
--- /dev/null
+++ b/java/src/IceGridGUI/LiveDeployment/Node.java
@@ -0,0 +1,767 @@
+// **********************************************************************

+//

+// Copyright (c) 2003-2006 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 IceGridGUI.LiveDeployment;

+

+import java.awt.Component;

+import java.awt.Cursor;

+

+import javax.swing.Icon;

+import javax.swing.JOptionPane;

+import javax.swing.JPopupMenu;

+import javax.swing.JTree;

+import javax.swing.SwingUtilities;

+import javax.swing.tree.DefaultTreeCellRenderer;

+import javax.swing.tree.TreeModel;

+import javax.swing.tree.TreePath;

+

+import java.text.NumberFormat;

+

+import java.util.Enumeration;

+

+import IceGrid.*;

+import IceGridGUI.*;

+

+class Node extends ListTreeNode

+{

+    //

+    // Actions

+    //

+    public boolean[] getAvailableActions()

+    {

+	boolean[] actions = new boolean[ACTION_COUNT];

+	actions[SHUTDOWN_NODE] = _up;

+	return actions;

+    }

+

+    public void shutdownNode()

+    {

+	final String prefix = "Shutting down node '" + _id + "'...";

+	getCoordinator().getStatusBar().setText(prefix);

+

+	AMI_Admin_shutdownNode cb = new AMI_Admin_shutdownNode()

+	    {

+		//

+		// Called by another thread!

+		//

+		public void ice_response()

+		{

+		    amiSuccess(prefix);

+		}

+		

+		public void ice_exception(Ice.UserException e)

+		{

+		    amiFailure(prefix, "Failed to shutdown " + _id, e);

+		}

+

+		public void ice_exception(Ice.LocalException e)

+		{

+		    amiFailure(prefix, "Failed to shutdown " + _id, 

+			       e.toString());

+		}

+	    };

+

+	try

+	{   

+	    getCoordinator().getMainFrame().setCursor(

+		Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));

+	    

+	    getCoordinator().getAdmin().shutdownNode_async(cb, _id);

+	}

+	catch(Ice.LocalException e)

+	{

+	    failure(prefix, "Failed to shutdown " + _id, e.toString());

+	}

+	finally

+	{

+	    getCoordinator().getMainFrame().setCursor(

+		Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));

+	}

+    }

+

+    public JPopupMenu getPopupMenu()

+    {

+	LiveActions la = getCoordinator().getLiveActionsForPopup();

+

+	if(_popup == null)

+	{

+	    _popup = new JPopupMenu();

+	    _popup.add(la.get(SHUTDOWN_NODE));

+	}

+	

+	la.setTarget(this);

+	return _popup;

+    }

+

+

+    public Editor getEditor()

+    {

+	if(_editor == null)

+	{

+	    _editor = new NodeEditor();

+	}

+	_editor.show(this);

+	return _editor;

+    }

+

+    public Component getTreeCellRendererComponent(

+	    JTree tree,

+	    Object value,

+	    boolean sel,

+	    boolean expanded,

+	    boolean leaf,

+	    int row,

+	    boolean hasFocus) 

+    {

+	if(_cellRenderer == null)

+	{

+	    //

+	    // Initialization

+	    //

+	    _cellRenderer = new DefaultTreeCellRenderer();

+	    _nodeUp = Utils.getIcon("/icons/16x16/node_up.png");

+	    _nodeDown = Utils.getIcon("/icons/16x16/node_down.png");

+	}

+

+	if(_up)

+	{

+	    _cellRenderer.setToolTipText("Up and running");

+	    if(expanded)

+	    {

+		_cellRenderer.setOpenIcon(_nodeUp);

+	    }

+	    else

+	    {

+		_cellRenderer.setClosedIcon(_nodeUp);

+	    }

+	}

+	else

+	{

+	    _cellRenderer.setToolTipText("Not running");

+	    if(expanded)

+	    {

+		_cellRenderer.setOpenIcon(_nodeDown);

+	    }

+	    else

+	    {

+		_cellRenderer.setClosedIcon(_nodeDown);

+	    }

+	}

+

+	return _cellRenderer.getTreeCellRendererComponent(

+	    tree, value, sel, expanded, leaf, row, hasFocus);

+    }

+

+    Node(Root parent, NodeDynamicInfo info)

+    {

+	super(parent, info.name);

+	up(info, false);

+    }

+

+

+    Node(Root parent, ApplicationDescriptor appDesc, 

+	 String nodeName, NodeDescriptor nodeDesc)

+    {

+	super(parent, nodeName);

+	add(appDesc, nodeDesc);

+    }

+

+    Node(Root parent, ApplicationDescriptor appDesc, NodeUpdateDescriptor update)

+    {

+	super(parent, update.name);

+

+	NodeDescriptor nodeDesc = new NodeDescriptor(

+	    update.variables,

+	    update.serverInstances,

+	    update.servers,

+	    update.loadFactor.value,

+	    update.description.value);

+	    

+	appDesc.nodes.put(_id, nodeDesc);

+	add(appDesc, nodeDesc);

+    }

+

+

+    void add(ApplicationDescriptor appDesc, NodeDescriptor nodeDesc)

+    {

+	ApplicationData data = new ApplicationData();

+	data.descriptor = nodeDesc;

+	data.resolver = new Utils.Resolver(new java.util.Map[]{appDesc.variables, nodeDesc.variables});

+	data.resolver.put("application", appDesc.name);

+	data.resolver.put("node", _id);

+

+	_map.put(appDesc.name, data);

+	

+	java.util.Iterator p = nodeDesc.serverInstances.iterator();

+	while(p.hasNext())

+	{

+	    ServerInstanceDescriptor desc = (ServerInstanceDescriptor)p.next();

+	    insertServer(createServer(appDesc, data.resolver, desc));

+	}

+	

+	p = nodeDesc.servers.iterator();

+	while(p.hasNext())

+	{

+	    ServerDescriptor desc = (ServerDescriptor)p.next();

+	    insertServer(createServer(appDesc, data.resolver, desc));

+	}

+    }

+

+   

+

+    boolean remove(String appName)

+    {

+	_map.remove(appName);

+	if(_map.isEmpty() && !_up)

+	{

+	    return true;

+	}

+

+	java.util.List toRemove = new java.util.LinkedList();

+	int[] toRemoveIndices = new int[_children.size()];

+	int i = 0;

+	

+	for(int index = 0; index < _children.size(); ++index)

+	{

+	    Server server = (Server)_children.get(i);

+	    if(server.getApplication().name.equals(appName))

+	    {

+		toRemove.add(server);

+		toRemoveIndices[i++] = index;

+	    }

+	}

+	toRemoveIndices = resize(toRemoveIndices, toRemove.size());

+	_children.removeAll(toRemove);

+	getRoot().getTreeModel().nodesWereRemoved(this, toRemoveIndices, toRemove.toArray());

+

+	return false;

+    }

+

+    void update(ApplicationDescriptor appDesc, NodeUpdateDescriptor update,

+		boolean variablesChanged, java.util.Set serviceTemplates,

+		java.util.Set serverTemplates)

+    {

+	ApplicationData data = (ApplicationData)_map.get(appDesc.name);

+	NodeDescriptor nodeDesc = data.descriptor;

+	java.util.Set freshServers = new java.util.HashSet();

+	

+	if(update != null)

+	{

+	    //

+	    // Update various fields of nodeDesc

+	    //

+	    if(update.description != null)

+	    {

+		nodeDesc.description = update.description.value;

+	    }

+	    if(update.loadFactor != null)

+	    {

+		nodeDesc.loadFactor = update.loadFactor.value;

+	    }

+	

+	    nodeDesc.variables.keySet().removeAll(java.util.Arrays.asList(update.removeVariables));

+	    nodeDesc.variables.putAll(update.variables);

+	    

+	    if(!variablesChanged)

+	    {

+		variablesChanged = update.removeVariables.length > 0 ||

+		    !update.variables.isEmpty();

+	    }

+

+	    //

+	    // Remove servers

+	    //

+	    for(int i = 0; i < update.removeServers.length; ++i)

+	    {

+		Server server = findServer(update.removeServers[i]);

+		

+		ServerInstanceDescriptor sid =

+		    server.getInstanceDescriptor();

+		if(sid != null)

+		{

+		    nodeDesc.serverInstances.remove(sid);

+		}

+		else

+		{

+		    nodeDesc.servers.remove(server.getServerDescriptor());

+		}

+

+		int index = getIndex(server); 

+		_children.remove(server);

+		getRoot().getTreeModel().nodesWereRemoved(this, new int[]{index}, new Object[]{server});

+	    }

+

+	    //

+	    // Add/update servers

+	    //

+	    java.util.Iterator p = update.serverInstances.iterator();

+	    while(p.hasNext())

+	    {

+		ServerInstanceDescriptor desc = (ServerInstanceDescriptor)p.next();

+		Server server = createServer(appDesc, data.resolver, desc);

+		

+		Server oldServer = findServer(server.getId());

+		if(oldServer == null)

+		{

+		    insertServer(server);

+		    freshServers.add(server);

+		}

+		else

+		{

+		    oldServer.rebuild(server);

+		    freshServers.add(oldServer);

+		}

+		nodeDesc.serverInstances.add(desc);

+	    }

+	    

+	    p = update.servers.iterator();

+	    while(p.hasNext())

+	    {

+		ServerDescriptor desc = (ServerDescriptor)p.next();

+		Server server = createServer(appDesc, data.resolver, desc);

+		

+		Server oldServer = findServer(server.getId());

+		if(oldServer == null)

+		{

+		    insertServer(server);

+		    freshServers.add(server);

+		}

+		else

+		{

+		    oldServer.rebuild(server);

+		    freshServers.add(oldServer);

+		}

+		nodeDesc.servers.add(desc);

+	    }

+	}

+	

+	if(variablesChanged || !serviceTemplates.isEmpty() || !serverTemplates.isEmpty())

+	{

+	    //

+	    // Rebuild every other server

+	    //

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

+	    while(p.hasNext())

+	    {

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

+		if(!freshServers.contains(server))

+		{

+		    server.rebuild(data.resolver,

+				   variablesChanged, 

+				   serviceTemplates, serverTemplates);

+		}

+	    }

+	}

+    }

+    

+    NodeInfo getStaticInfo()

+    {

+	if(_info == null)

+	{

+	    return null;

+	}

+	else

+	{

+	    return _info.info;

+	}

+    }

+    

+    boolean isRunningWindows()

+    {

+	return _windows;

+    }

+

+    void up(NodeDynamicInfo info, boolean fireEvent)

+    {

+	_up = true;

+	_info = info;

+	_windows = info.info.os.toLowerCase().startsWith("windows");

+	

+	//

+	// Tell every server on this node

+	//

+	java.util.Set updatedServers = new java.util.HashSet();

+	java.util.Iterator p = _info.servers.iterator();

+	while(p.hasNext())

+	{

+	    ServerDynamicInfo sinfo = (ServerDynamicInfo)p.next();

+	    Server server = findServer(sinfo.id);

+	    if(server != null)

+	    {

+		server.update(sinfo.state, sinfo.pid, sinfo.enabled, true);

+		updatedServers.add(server);

+	    }

+	}

+	p = _children.iterator();

+	while(p.hasNext())

+	{

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

+	    if(!updatedServers.contains(server))

+	    {

+		server.update(ServerState.Inactive, 0, true, true);

+	    }

+	}

+

+	//

+	// Tell adapters

+	//

+	p = _children.iterator();

+	int updateCount = 0;

+	while(p.hasNext() && updateCount < _info.adapters.size())

+	{

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

+	    updateCount += server.updateAdapters(_info.adapters);

+	}

+

+	if(fireEvent)

+	{

+	    getRoot().getTreeModel().nodeChanged(this);

+	}

+    }

+

+    boolean down()

+    {

+	_up = false;

+	_info.servers.clear();

+	_info.adapters.clear();

+

+	if(_children.isEmpty())

+	{

+	    return true;

+	}

+	else

+	{

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

+	    while(p.hasNext())

+	    {

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

+		server.nodeDown();

+	    }

+

+	    getRoot().getTreeModel().nodeChanged(this);

+	    return false;

+	}

+    }

+

+    void updateServer(ServerDynamicInfo updatedInfo)

+    {

+	if(_info != null)

+	{

+	    java.util.ListIterator p = _info.servers.listIterator();

+	    while(p.hasNext())

+	    {

+		ServerDynamicInfo sinfo = (ServerDynamicInfo)p.next();

+		if(sinfo.id.equals(updatedInfo.id))

+		{

+		    p.set(updatedInfo);

+		    break;

+		}

+	    }

+	}

+

+	Server server = findServer(updatedInfo.id);

+	if(server != null)

+	{

+	    server.update(updatedInfo.state, updatedInfo.pid, 

+			  updatedInfo.enabled, true);

+	}

+    }

+

+    void updateAdapter(AdapterDynamicInfo updatedInfo)

+    {

+	if(_info != null)

+	{

+	    java.util.ListIterator p = _info.adapters.listIterator();

+	    while(p.hasNext())

+	    {

+		AdapterDynamicInfo ainfo = (AdapterDynamicInfo)p.next();

+		if(ainfo.id.equals(updatedInfo.id))

+		{

+		    p.set(updatedInfo);

+		    break;

+		}

+	    }

+	}

+

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

+	while(p.hasNext())

+	{

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

+	    if(server.updateAdapter(updatedInfo))

+	    {

+		break;

+	    }

+	}

+    }

+    

+    Ice.ObjectPrx getProxy(String adapterId)

+    {

+	if(_info != null)

+	{

+	    java.util.ListIterator p = _info.adapters.listIterator();

+	    while(p.hasNext())

+	    {

+		AdapterDynamicInfo ainfo = (AdapterDynamicInfo)p.next();

+		if(ainfo.equals(adapterId))

+		{

+		    return ainfo.proxy;

+		}

+	    }

+	}

+	return null;

+    }

+

+    java.util.SortedMap getLoadFactors()

+    {

+	java.util.SortedMap result = new java.util.TreeMap();

+	

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

+	while(p.hasNext())

+	{

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

+	    

+	    ApplicationData ad = (ApplicationData)entry.getValue();

+	    

+	    String val = ad.resolver.substitute(ad.descriptor.loadFactor);

+	    if(val.length() == 0)

+	    {

+		val = "Default";

+	    }

+

+	    result.put(entry.getKey(), val);

+	}

+	return result;

+    }

+

+

+    void showLoad()

+    {

+	AMI_Admin_getNodeLoad cb = new AMI_Admin_getNodeLoad()

+	    {

+		public void ice_response(LoadInfo loadInfo)

+		{

+		    NumberFormat format;

+		    if(_windows)

+		    {

+			format = NumberFormat.getPercentInstance();

+			format.setMaximumFractionDigits(1);

+			format.setMinimumFractionDigits(1);

+		    }

+		    else

+		    {

+			format = NumberFormat.getNumberInstance();

+			format.setMaximumFractionDigits(2);

+			format.setMinimumFractionDigits(2);

+		    }

+		    

+		    final String load = 

+			format.format(loadInfo.avg1) + " " +

+			format.format(loadInfo.avg5) + " " +

+			format.format(loadInfo.avg15); 

+

+		    SwingUtilities.invokeLater(new Runnable() 

+			{

+			    public void run() 

+			    {

+				_editor.setLoad(load, Node.this);

+			    }

+			});

+		}

+

+		public void ice_exception(final Ice.UserException e)

+		{

+		    SwingUtilities.invokeLater(new Runnable() 

+			{

+			    public void run() 

+			    {

+				if(e instanceof IceGrid.NodeNotExistException)

+				{

+				    _editor.setLoad(

+					"Error: this node is not known to this IceGrid Registry",

+					Node.this);

+				}

+				else if(e instanceof IceGrid.NodeUnreachableException)

+				{

+				    _editor.setLoad("Error: cannot reach this node", Node.this);

+				}

+				else

+				{

+				    _editor.setLoad("Error: " + e.toString(), Node.this);

+				}

+			    }

+			});

+		}	      

+		

+		public void ice_exception(final Ice.LocalException e)

+		{

+		    SwingUtilities.invokeLater(new Runnable() 

+			{

+			    public void run() 

+			    {

+				_editor.setLoad("Error: " + e.toString(), Node.this);

+			    }

+			});

+		}

+	    };

+

+	try

+	{   

+	    getCoordinator().getMainFrame().setCursor(

+		Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));

+	    

+	    IceGrid.AdminPrx admin = getCoordinator().getAdmin();

+	    if(admin == null)

+	    {

+		_editor.setLoad("Unknown", this);

+	    }

+	    else

+	    {

+		admin.getNodeLoad_async(cb, _id);

+	    }

+	}

+	catch(Ice.LocalException e)

+	{

+	    _editor.setLoad("Error: " + e.toString(), this);

+	}

+	finally

+	{

+	    getCoordinator().getMainFrame().setCursor(

+		Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));

+	}

+    }

+

+    

+    private Server createServer(ApplicationDescriptor application, 

+				Utils.Resolver resolver, ServerInstanceDescriptor instanceDescriptor)

+    {

+	//

+	// Find template

+	//

+	TemplateDescriptor templateDescriptor = 

+	    (TemplateDescriptor)application.serverTemplates.get(instanceDescriptor.template);

+	assert templateDescriptor != null;

+	    

+	ServerDescriptor serverDescriptor = 

+	    (ServerDescriptor)templateDescriptor.descriptor;

+	

+	assert serverDescriptor != null;

+	

+	//

+	// Build resolver

+	//

+	Utils.Resolver instanceResolver = 

+	    new Utils.Resolver(resolver, 

+			       instanceDescriptor.parameterValues,

+			       templateDescriptor.parameterDefaults);

+	

+	String serverId = instanceResolver.substitute(serverDescriptor.id);

+	instanceResolver.put("server", serverId);

+	

+	//

+	// Lookup dynamic info

+	//

+	ServerState serverState = _up ? ServerState.Inactive : null;

+	int pid = 0;

+	boolean enabled = true;

+	if(_info != null)

+	{

+	    java.util.Iterator p = _info.servers.iterator();

+	    while(p.hasNext())

+	    {

+		ServerDynamicInfo sinfo = (ServerDynamicInfo)p.next();

+		if(sinfo.id.equals(serverId))

+		{

+		    serverState = sinfo.state;

+		    pid = sinfo.pid;

+		    enabled = sinfo.enabled;

+		    break;

+		}

+	    }

+	}

+

+	//

+	// Create server

+	//

+	return new Server(this, serverId, instanceResolver, instanceDescriptor, 

+			  serverDescriptor, application,

+			  serverState, pid, enabled);

+

+    }

+

+    private Server createServer(ApplicationDescriptor application, 

+				Utils.Resolver resolver, ServerDescriptor serverDescriptor)

+    {

+	//

+	// Build resolver

+	//

+	Utils.Resolver instanceResolver = new Utils.Resolver(resolver);

+	String serverId = instanceResolver.substitute(serverDescriptor.id);

+	instanceResolver.put("server", serverId);	

+

+	//

+	// Lookup dynamic info

+	//

+	ServerState serverState = _up ? ServerState.Inactive : null;

+	int pid = 0;

+	boolean enabled = true;

+	if(_info != null)

+	{

+	    java.util.Iterator p = _info.servers.iterator();

+	    while(p.hasNext())

+	    {

+		ServerDynamicInfo sinfo = (ServerDynamicInfo)p.next();

+		if(sinfo.id.equals(serverId))

+		{

+		    serverState = sinfo.state;

+		    pid = sinfo.pid;

+		    enabled = sinfo.enabled;

+		    break;

+		}

+	    }

+	}

+

+	//

+	// Create server

+	//

+	return new Server(this, serverId, instanceResolver, null, serverDescriptor, 

+			  application, serverState, pid, enabled);

+

+    }

+

+    private void insertServer(Server server)

+    {

+	insertSortedChild(server, _children, getRoot().getTreeModel());

+    }

+

+    private Server findServer(String id)

+    {

+	return (Server)find(id, _children);

+    }

+ 

+    static class ApplicationData

+    {

+	NodeDescriptor descriptor;

+	Utils.Resolver resolver;

+    }

+

+    //

+    // Application name to ApplicationData

+    //

+    private final java.util.SortedMap _map = new java.util.TreeMap();

+    

+    private boolean _up = false;

+    private NodeDynamicInfo _info;

+    private boolean _windows = false;

+

+    static private DefaultTreeCellRenderer _cellRenderer;

+    static private Icon _nodeUp;

+    static private Icon _nodeDown;

+

+    static private NodeEditor _editor;

+    static private JPopupMenu _popup;

+}