Simplified Application view; fixed PropertySets issues

1 files changed, 557 insertions, 0 deletions

diff --git a/java/src/IceGridGUI/Application/PlainServer.java b/java/src/IceGridGUI/Application/PlainServer.java
new file mode 100755
index 00000000000..17cae6be7cc
--- /dev/null
+++ b/java/src/IceGridGUI/Application/PlainServer.java
@@ -0,0 +1,557 @@
+// **********************************************************************

+//

+// 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 IceGridGUI.Application;

+

+import java.awt.Component;

+

+import javax.swing.Icon;

+import javax.swing.JPopupMenu;

+import javax.swing.JTree;

+

+import javax.swing.tree.TreeCellRenderer;

+import javax.swing.tree.DefaultTreeCellRenderer;

+

+import IceGrid.*;

+import IceGridGUI.*;

+

+class PlainServer extends Communicator implements Server

+{ 

+    static public ServerDescriptor

+    copyDescriptor(ServerDescriptor sd)

+    {

+	ServerDescriptor copy = (ServerDescriptor)sd.clone();

+

+	copy.adapters = Adapter.copyDescriptors(copy.adapters);

+	copy.dbEnvs = DbEnv.copyDescriptors(copy.dbEnvs);

+

+	copy.propertySet = PropertySet.copyDescriptor(copy.propertySet);

+	

+	copy.distrib = (DistributionDescriptor)copy.distrib.clone();

+

+	if(copy instanceof IceBoxDescriptor)

+	{

+	    IceBoxDescriptor ib = (IceBoxDescriptor)copy;

+	    ib.services = ServiceInstance.copyDescriptors(ib.services);

+	}

+	return copy;

+    }

+    

+    static public void shallowRestore(ServerDescriptor from, ServerDescriptor into)

+    {

+	//

+	// When editing a server or server template, if we update properties, 

+	// we replace the entire field

+	//

+	into.propertySet = from.propertySet;

+	into.description = from.description;

+	into.id = from.id;

+	into.exe = from.exe;

+	into.options = from.options;

+	into.envs = from.envs;

+	into.activation = from.activation;

+	into.activationTimeout = from.activationTimeout;

+	into.deactivationTimeout = from.deactivationTimeout;

+	into.applicationDistrib = from.applicationDistrib;

+	into.distrib.icepatch = from.distrib.icepatch;

+	into.distrib.directories = from.distrib.directories;

+    }

+

+    static public ServerDescriptor newServerDescriptor()

+    {

+	return new ServerDescriptor(

+	    new java.util.LinkedList(),

+	    new PropertySetDescriptor(new String[0], new java.util.LinkedList()),

+	    new java.util.LinkedList(),

+	    "",

+	    "NewServer",

+	    "",

+	    "",

+	    new java.util.LinkedList(),

+	    new java.util.LinkedList(),

+	    "manual",

+	    "",

+	    "",

+	    true,

+	    new DistributionDescriptor("", new java.util.LinkedList()),

+	    false // Allocatable

+	    );

+    }

+

+    static public IceBoxDescriptor newIceBoxDescriptor()

+    {

+	AdapterDescriptor serviceManager = new AdapterDescriptor(

+	    "IceBox.ServiceManager",

+	    "", 

+	    "", // direct-adapter by default

+	    "",

+	    true,

+	    true,

+	    new java.util.LinkedList(),

+	    false // Allocatable

+	    );

+

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

+	adapterList.add(serviceManager);

+	

+	PropertyDescriptor pd = 

+	    new PropertyDescriptor("IceBox.ServiceManager.Endpoints",

+				   "tcp -h 127.0.0.1");

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

+	properties.add(pd);

+

+	return new IceBoxDescriptor(

+	    adapterList,

+	    new PropertySetDescriptor(new String[0], properties),

+	    new java.util.LinkedList(),

+	    "",

+	    "NewIceBox",

+	    "",

+	    "",

+	    new java.util.LinkedList(),

+	    new java.util.LinkedList(),

+	    "manual",

+	    "",

+	    "",

+	    true,

+	    new DistributionDescriptor("", new java.util.LinkedList()),

+	    false, // Allocatable

+	    new java.util.LinkedList()

+	    );

+    }

+    

+    //

+    // Actions

+    //

+    public boolean[] getAvailableActions()

+    {

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

+	actions[COPY] = true;

+	

+	Object clipboard = getCoordinator().getClipboard();

+	if(clipboard != null && 

+	   (clipboard instanceof ServerDescriptor

+	    || clipboard instanceof ServerInstanceDescriptor))

+	{

+	    actions[PASTE] = true;

+	}

+

+	actions[DELETE] = true;

+	if(!_ephemeral)

+	{

+	    actions[SHOW_VARS] = true;

+	    actions[SUBSTITUTE_VARS] = true;

+	}

+	

+	actions[NEW_ADAPTER] = !_services.initialized();

+	actions[NEW_SERVICE] = _services.initialized();

+	actions[NEW_DBENV] = !_services.initialized();

+

+	return actions;

+    }

+    public JPopupMenu getPopupMenu()

+    {

+	ApplicationActions actions = getCoordinator().getActionsForPopup();

+	if(_popup == null)

+	{

+	    _popup = new JPopupMenu();

+	    _popup.add(actions.get(NEW_ADAPTER));

+	    _popup.add(actions.get(NEW_DBENV));

+	    _popup.add(actions.get(NEW_SERVICE));

+	    _popup.add(actions.get(NEW_SERVICE_FROM_TEMPLATE));

+	}

+	actions.setTarget(this);

+	return _popup;

+    }

+    public void copy()

+    {

+	getCoordinator().setClipboard(copyDescriptor(_descriptor));

+	getCoordinator().getActionsForMenu().get(PASTE).setEnabled(true);

+    }

+    

+    public Editor getEditor()

+    {

+	if(_editor == null)

+	{

+	    _editor = (PlainServerEditor)getRoot().getEditor(PlainServerEditor.class, this);

+	}

+	_editor.show(this);

+	return _editor;

+    }

+

+    protected Editor createEditor()

+    {

+	return new PlainServerEditor(getCoordinator().getMainFrame());

+    }

+	

+    public Component getTreeCellRendererComponent(

+	    JTree tree,

+	    Object value,

+	    boolean sel,

+	    boolean expanded,

+	    boolean leaf,

+	    int row,

+	    boolean hasFocus) 

+    {

+	if(_cellRenderer == null)

+	{

+	    //

+	    // Initialization

+	    //

+	    _cellRenderer = new DefaultTreeCellRenderer();

+

+	    _serverIcon = Utils.getIcon("/icons/16x16/server_inactive.png");

+	    _iceboxServerIcon = Utils.getIcon("/icons/16x16/icebox_server_inactive.png");

+	}

+	

+	boolean icebox = _descriptor instanceof IceBoxDescriptor;

+

+	if(expanded)

+	{	

+	    _cellRenderer.setOpenIcon(icebox ? _iceboxServerIcon : _serverIcon);

+	}

+	else

+	{

+	    _cellRenderer.setClosedIcon(icebox ? _iceboxServerIcon : _serverIcon);

+	} 

+	return _cellRenderer.getTreeCellRendererComponent(

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

+    }

+

+    public void destroy()

+    {

+	Node node = (Node)_parent;

+	

+	if(_ephemeral)

+	{

+	    node.removeServer(this);

+	}

+	else

+	{

+	    node.removeDescriptor(_descriptor);

+	    node.removeServer(this);

+	    node.getEditable().removeElement(_id, _editable, Server.class);

+	    getRoot().updated();

+	}

+    }

+

+    public Object getDescriptor()

+    {

+	return _descriptor;

+    }

+

+    public Object saveDescriptor()

+    {

+	ServerDescriptor clone = (ServerDescriptor)_descriptor.clone();

+	clone.distrib = (DistributionDescriptor)clone.distrib.clone();

+	return clone;

+    }

+

+    public void restoreDescriptor(Object savedDescriptor)

+    {

+	shallowRestore((ServerDescriptor)savedDescriptor, _descriptor);

+    }

+

+    //

+    // Builds the server and all its sub-tree

+    //

+    PlainServer(boolean brandNew, TreeNode parent, String serverId, 

+		Utils.Resolver resolver, ServerDescriptor serverDescriptor) 

+	throws UpdateFailedException

+    {

+	super(parent, serverId);

+	_ephemeral = false;

+	_editable = new Editable(brandNew);

+	rebuild(resolver, serverDescriptor);

+    }

+

+    PlainServer(TreeNode parent, String serverId, ServerDescriptor serverDescriptor)

+    {

+	super(parent, serverId);

+	_ephemeral = true;

+	_editable = null;

+	try

+	{

+	    rebuild(null, serverDescriptor);

+	}

+	catch(UpdateFailedException e)

+	{

+	    assert false;

+	}

+    }

+

+    static java.util.List createAttributes(ServerDescriptor descriptor)

+    {

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

+	attributes.add(createAttribute("id", descriptor.id));

+	if(descriptor.activation.length() > 0)

+	{

+	    attributes.add(createAttribute("activation", 

+					   descriptor.activation));

+	}

+	if(descriptor.activationTimeout.length() > 0)

+	{

+	    attributes.add(createAttribute("activation-timeout", 

+					   descriptor.activationTimeout));

+	}

+	if(!descriptor.applicationDistrib)

+	{

+	    attributes.add(createAttribute("application-distrib", "false")); 

+	}

+	if(descriptor.deactivationTimeout.length() > 0)

+	{

+	    attributes.add(createAttribute("deactivation-timeout", 

+					   descriptor.deactivationTimeout));

+	}

+	if(descriptor.exe.length() > 0)

+	{

+	    attributes.add(createAttribute("exe", descriptor.exe));

+	}

+	if(descriptor.pwd.length() > 0)

+	{

+	    attributes.add(createAttribute("pwd", descriptor.pwd));

+	}

+

+	return attributes;

+    }

+    

+    static void writeOptions(XMLWriter writer, java.util.List options)

+	throws java.io.IOException

+    {

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

+	while(p.hasNext())

+	{

+	    writer.writeElement("option", (String)p.next()); 

+	}

+    }

+    

+    static void writeEnvs(XMLWriter writer, java.util.List envs)

+	throws java.io.IOException

+    {

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

+	while(p.hasNext())

+	{

+	    writer.writeElement("env", (String)p.next()); 

+	}

+    }

+

+    void write(XMLWriter writer) throws java.io.IOException

+    {

+	if(!_ephemeral)

+	{

+	    if(isIceBox())

+	    {

+		writer.writeStartTag("icebox", 

+				     createAttributes(_descriptor));

+

+		if(_descriptor.description.length() > 0)

+		{

+		    writer.writeElement("description", _descriptor.description);

+		}

+		writeOptions(writer, _descriptor.options);

+		writeEnvs(writer, _descriptor.envs);

+		

+		writePropertySet(writer, "", _descriptor.propertySet);

+		writeDistribution(writer, _descriptor.distrib);

+

+		_adapters.write(writer);

+		_services.write(writer);

+		writer.writeEndTag("icebox");

+	    }

+	    else

+	    {

+		writer.writeStartTag("server", createAttributes(_descriptor));

+

+		if(_descriptor.description.length() > 0)

+		{

+		    writer.writeElement("description", _descriptor.description);

+		}

+		

+		writeOptions(writer, _descriptor.options);

+		writeEnvs(writer, _descriptor.envs);

+		

+		writePropertySet(writer, "", _descriptor.propertySet);

+		writeDistribution(writer, _descriptor.distrib);

+

+		_adapters.write(writer);

+		_dbEnvs.write(writer);

+		writer.writeEndTag("server");

+	    }

+	}

+    }

+

+

+    boolean isIceBox()

+    {

+	return _descriptor instanceof IceBoxDescriptor;

+    }

+

+    public Object rebuild(java.util.List editables) throws UpdateFailedException

+    {

+	Node node = (Node)_parent;

+	PlainServer newServer = node.createServer(false, _descriptor);

+

+	Object backup = null;

+

+	if(_id.equals(newServer.getId()))

+	{

+	    //

+	    // A simple update. We can't simply rebuild server because 

+	    // we need to keep a backup

+	    //

+	    if(_editable.isModified())

+	    {

+		newServer.getEditable().markModified();

+	    }

+

+	    node.removeServer(this);	    

+	    try

+	    {

+		node.insertServer(newServer, true);

+	    }

+	    catch(UpdateFailedException e)

+	    {

+		assert false; // impossible, we just removed a child with

+		              // this id

+	    }

+	}

+	else

+	{

+	    //

+	    // Typically, the id uses a variable whose definition changed

+	    //

+	    newServer.getEditable().markNew();

+	    node.removeServer(this);

+	    backup = node.getEditable().save();

+	    node.getEditable().removeElement(_id, _editable, Server.class);

+	    

+	    try

+	    {

+		node.insertServer(newServer, true);

+	    }

+	    catch(UpdateFailedException e)

+	    {

+		restore(backup);

+		throw e;

+	    }

+	}

+	

+	return backup;

+    }

+

+    public void restore(Object backupObj)

+    {

+	Editable backup = (Editable)backupObj;

+	Node node = (Node)_parent;

+

+	if(backup != null)

+	{

+	    node.getEditable().restore(backup);

+	}

+

+	TreeNode badServer = node.findChildWithDescriptor(_descriptor);

+

+	if(badServer != null)

+	{

+	    node.removeServer(badServer);

+	}

+	try

+	{

+	    node.insertServer(this, true);

+	}

+	catch(UpdateFailedException e)

+	{

+	    assert false; // impossible

+	}

+    }

+

+    void setServerDescriptor(ServerDescriptor descriptor)

+    {

+	_descriptor = descriptor;

+    }

+

+    //

+    // Update the server and all its subtree

+    //

+    void rebuild(Utils.Resolver resolver,  

+		 ServerDescriptor serverDescriptor) throws UpdateFailedException

+    {

+	assert serverDescriptor != null;

+	_resolver = resolver;

+	_descriptor = serverDescriptor;

+

+	_adapters.clear();

+	_dbEnvs.clear();

+	_services.clear();

+

+	if(!_ephemeral)

+	{

+	    _adapters.init(_descriptor.adapters);

+	    if(_descriptor instanceof IceBoxDescriptor)

+	    {

+		IceBoxDescriptor iceBoxDescriptor = (IceBoxDescriptor)_descriptor;

+		_services.init(iceBoxDescriptor.services);

+   

+		//

+		// IceBox has not dbEnv

+		//

+		assert _descriptor.dbEnvs.size() == 0;

+	    }

+	    else

+	    {

+		_dbEnvs.init(_descriptor.dbEnvs);

+	    }

+	}

+    }

+

+    CommunicatorDescriptor getCommunicatorDescriptor()

+    {

+	return _descriptor;

+    }

+

+    Utils.Resolver getResolver()

+    {

+	return _resolver;

+    }

+    

+    public Editable getEditable()

+    {

+	return _editable;

+    }

+

+    Editable getEnclosingEditable()

+    {

+	return _editable;

+    }

+

+    java.util.List findInstances(boolean includeTemplate)

+    {

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

+	result.add(this);

+	return result;

+    }

+

+    public boolean isEphemeral()

+    {

+	return _ephemeral;

+    }

+

+    private ServerDescriptor _descriptor;

+    private final boolean _ephemeral;

+

+    private PlainServerEditor _editor;

+

+    private Utils.Resolver _resolver;

+    private Editable _editable;

+    

+    static private DefaultTreeCellRenderer _cellRenderer;

+    static private Icon _serverIcon;

+    static private Icon _iceboxServerIcon;

+ 

+    static private JPopupMenu _popup;

+}