Logo Search packages:      
Sourcecode: zeroc-ice-java version File versions  Download package

Root.java

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

import java.awt.Component;
import java.awt.Cursor;

import javax.swing.JOptionPane;
import javax.swing.JPopupMenu;
import javax.swing.JTree;
import javax.swing.tree.DefaultTreeCellRenderer;
import javax.swing.tree.DefaultTreeModel;
import javax.swing.tree.TreePath;

import java.io.File;

import java.util.Enumeration;

import IceGrid.*;
import IceGridGUI.*;

public class Root extends ListTreeNode
{
    //
    // Construct a normal, existing Application
    //
    public Root(Coordinator coordinator, ApplicationDescriptor desc, 
            boolean live, File file)
    {
      super(false, null, desc.name);
      _coordinator = coordinator;
      _descriptor = desc;

      _file = file;
      _live = live;

      try
      {
          init();
      }
      catch(UpdateFailedException e)
      {
          //
          // Impossible
          //
          System.err.println(e.toString());
          assert false;
      }
    }
   
    //
    // Construct a new Application
    //
    public Root(Coordinator coordinator, ApplicationDescriptor desc)
    {
      super(true, null, desc.name);
      _coordinator = coordinator;
      _descriptor = desc;

      _file = null;
      _live = false;
      
      try
      {
          init();
      }
      catch(UpdateFailedException e)
      {
          //
          // Impossible
          //
          assert false;
      }
    }

   
    private void init() throws UpdateFailedException
    {
      _resolver = new Utils.Resolver(_descriptor.variables);
      _resolver.put("application", _descriptor.name);

      _origVariables = _descriptor.variables;
      _origDescription = _descriptor.description;
      _origDistrib = (DistributionDescriptor)_descriptor.distrib.clone();

      _propertySets = new PropertySets(this, _descriptor.propertySets);
      _replicaGroups = new ReplicaGroups(this, _descriptor.replicaGroups);       
      _serviceTemplates = new ServiceTemplates(this, _descriptor.serviceTemplates);
      _serverTemplates = new ServerTemplates(this, _descriptor.serverTemplates);
      _nodes = new Nodes(this, _descriptor.nodes);

      _children.add(_nodes);
      _children.add(_propertySets);
      _children.add(_replicaGroups);
      _children.add(_serverTemplates);
      _children.add(_serviceTemplates);

      _tree = new JTree(this, true);
      _treeModel = (DefaultTreeModel)_tree.getModel();
    }


    static public ApplicationDescriptor
    copyDescriptor(ApplicationDescriptor ad)
    {
      ApplicationDescriptor copy = (ApplicationDescriptor)ad.clone();
      
      copy.propertySets = PropertySets.copyDescriptors(copy.propertySets);

      copy.replicaGroups = 
          ReplicaGroups.copyDescriptors(copy.replicaGroups);
      
      copy.serverTemplates = 
          ServerTemplates.copyDescriptors(copy.serverTemplates);
      
      copy.serviceTemplates = 
          ServiceTemplates.copyDescriptors(copy.serviceTemplates);
      
      copy.nodes = Nodes.copyDescriptors(copy.nodes);

      copy.distrib = (DistributionDescriptor)copy.distrib.clone();
      return copy;
    }

    public Editor getEditor()
    {
      if(_editor == null)
      {
          _editor = (ApplicationEditor) 
            getEditor(ApplicationEditor.class, this);
      }
      _editor.show(this);
      return _editor;
    }

    protected Editor createEditor()
    {
      return new ApplicationEditor();
    }

    public TreeNode findNodeLike(TreePath path, boolean exactMatch)
    {
      TreeNode result = null;
      if(path == null)
      {
          return null;
      }

      for(int i = 0; i < path.getPathCount(); ++i)
      {
          TreeNode node = (TreeNode)path.getPathComponent(i);
          
          if(result == null)
          {
            if(node.getId().equals(_id))
            {
                result = this;
            }
            else
            {
                return null;
            }
          }
          else
          {
            TreeNode newNode = result.findChildLike(node);
            if(newNode == null)
            {
                if(exactMatch)
                {
                  return null;
                }
                else
                {
                  return result;
                }
            }
            else
            {
                result = newNode;
            }
          }
      }

      return result;
    }
    
    //
    // Check that this node is attached to the tree
    //
    public boolean hasNode(TreeNode node)
    {
      while(node != this)
      {
          TreeNode parent = (TreeNode)node.getParent();
          if(parent == null || parent.getIndex(node) == -1)
          {
            return false;
          }
          else
          {
            node = parent;
          }
      }
      return true;
    }

    public void setSelectedNode(TreeNode node)
    {
      _tree.setSelectionPath(node.getPath());
    }

    public TreeNode getSelectedNode()
    {
      TreePath path = _tree.getSelectionPath();
      if(path == null)
      {
          return null;
      }
      else
      {
          return (TreeNode)path.getLastPathComponent();
      }
    }

    public void selectServer(String nodeName, String serverId)
    {
      TreeNode target = _nodes;
      if(target != null)
      {
          Node node = (Node)target.findChild(nodeName);
          if(node != null)
          {
            target = node;
            Server server = node.findServer(serverId);
            if(server != null)
            {
                target = (TreeNode)server;
            }
          }
          setSelectedNode(target);
      }
    }

    public Component getTreeCellRendererComponent(
          JTree tree,
          Object value,
          boolean sel,
          boolean expanded,
          boolean leaf,
          int row,
          boolean hasFocus) 
    {
      if(_cellRenderer == null)
      {
          _cellRenderer = new DefaultTreeCellRenderer();
          _cellRenderer.setOpenIcon(
            Utils.getIcon("/icons/16x16/application_open.png"));
          _cellRenderer.setClosedIcon(
            Utils.getIcon("/icons/16x16/application_closed.png"));
      }

      return _cellRenderer.getTreeCellRendererComponent(
          tree, value, sel, expanded, leaf, row, hasFocus);
    }

    public boolean[] getAvailableActions()
    {
      boolean[] actions = new boolean[ACTION_COUNT];

      actions[COPY] = true;
      actions[DELETE] = true;

      Object descriptor =  _coordinator.getClipboard();
      if(descriptor != null)
      {
          actions[PASTE] = descriptor instanceof ApplicationDescriptor;
      }

      actions[SHOW_VARS] = true;
      actions[SUBSTITUTE_VARS] = true;    
      actions[NEW_NODE] = true;
      actions[NEW_PROPERTY_SET] = true;
      actions[NEW_REPLICA_GROUP] = true;
      actions[NEW_TEMPLATE_SERVER] = true;
      actions[NEW_TEMPLATE_SERVER_ICEBOX] = true;
      actions[NEW_TEMPLATE_SERVICE] = true;

      return actions;
    }

    public JPopupMenu getPopupMenu()
    {
      ApplicationActions actions = _coordinator.getActionsForPopup();
      if(_popup == null)
      {
          _popup = new JPopupMenu();
          _popup.add(actions.get(NEW_NODE));
          _popup.add(actions.get(NEW_PROPERTY_SET));
          _popup.add(actions.get(NEW_REPLICA_GROUP));
          _popup.addSeparator();
          _popup.add(actions.get(NEW_TEMPLATE_SERVER));
          _popup.add(actions.get(NEW_TEMPLATE_SERVER_ICEBOX));
          _popup.addSeparator();
          _popup.add(actions.get(NEW_TEMPLATE_SERVICE));
      }
      actions.setTarget(this);
      return _popup;
    }

    public void copy()
    {
      _coordinator.setClipboard(copyDescriptor(_descriptor));
      _coordinator.getActionsForMenu().get(PASTE).setEnabled(true);
    }
    public void paste()
    {
      _coordinator.pasteApplication();
    }
    public void newNode()
    {
      _nodes.newNode();
    }
    public void newPropertySet()
    {
      _propertySets.newPropertySet();
    }
    public void newReplicaGroup()
    {
      _replicaGroups.newReplicaGroup();
    }
    public void newTemplateServer()
    {
      _serverTemplates.newTemplateServer();
    }
    public void newTemplateServerIceBox()
    {
      _serverTemplates.newTemplateServerIceBox();
    }
    public void newTemplateService()
    {
      _serviceTemplates.newTemplateService();
    }
    
    public void save()
    {
      if(_live)
      {
          saveToRegistry();
      }
      else if(_file != null)
      {
          File file = _coordinator.saveToFile(false, this, _file);
          if(file != null)
          {
            _file = file;
            commit();
            _coordinator.getSaveAction().setEnabled(false);
            _coordinator.getDiscardUpdatesAction().setEnabled(false);
          }
      }
      else
      {
          assert false;
      }
    }

    public void saveToRegistry()
    {
      //
      // To be run in GUI thread when exclusive write access is acquired
      //
      Runnable runnable = new Runnable()
          {
            public void run()
            {
                _coordinator.getMainFrame().setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
                try
                {
                  if(_live && _canUseUpdateDescriptor)
                  {
                      ApplicationUpdateDescriptor updateDescriptor = createUpdateDescriptor();
                      if(updateDescriptor != null)
                      {
                        _coordinator.getAdmin().updateApplication(updateDescriptor);
                        commit();
                        _skipUpdates++;
                      }
                  }
                  else
                  {
                      //
                      // Add or sync application
                      //
                      if(_coordinator.getLiveDeploymentRoot().getApplicationDescriptor(_id) == null)
                      {
                        assert _live == false;
                        _coordinator.getAdmin().addApplication(_descriptor);
                        commit();
                        liveReset();
                        _coordinator.addLiveApplication(Root.this);
                      }
                      else
                      {
                        _coordinator.getAdmin().syncApplication(_descriptor);
                        commit();

                        if(_live)
                        {
                            liveReset();
                            _skipUpdates++;
                        }
                        else
                        {
                            //
                            // Make this tab live or close it if there is one already open
                            //
                            ApplicationPane app = _coordinator.getLiveApplication(_id);
                            if(app == null)
                            {
                              liveReset();
                              _coordinator.addLiveApplication(Root.this);
                            }
                            else
                            {
                              boolean selected = isSelected();
                              _coordinator.getMainPane().removeApplication(Root.this);
                              if(selected)
                              {
                                  _coordinator.getMainPane().setSelectedComponent(app);
                              }
                            }
                        }
                      }
                  }
                  if(isSelected())
                  {
                      _coordinator.getSaveAction().setEnabled(false);
                      _coordinator.getSaveToRegistryAction().setEnabled(false);
                      _coordinator.getDiscardUpdatesAction().setEnabled(false);
                  }
                }
                catch(DeploymentException e)
                {
                  JOptionPane.showMessageDialog(
                      _coordinator.getMainFrame(),
                      "Application '" + _id + "': "+ e.reason,
                      "Deployment Exception",
                      JOptionPane.ERROR_MESSAGE);
                }
                catch(ApplicationNotExistException e)
                {
                  //
                  // Should never happen
                  //
                  JOptionPane.showMessageDialog(
                      _coordinator.getMainFrame(),
                      "Application '" + _id + "' was not found in the IceGrid registry",
                      "Deployment Exception",
                      JOptionPane.ERROR_MESSAGE);
                }
                catch(AccessDeniedException e)
                {
                  //
                  // Should never happen
                  //
                  _coordinator.accessDenied(e);
                }
                catch(Ice.LocalException e)
                {
                  JOptionPane.showMessageDialog(
                      _coordinator.getMainFrame(),
                      e.toString(),
                      "Communication Exception",
                      JOptionPane.ERROR_MESSAGE);
                }
                finally
                {
                  _coordinator.getMainFrame().setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
                  _coordinator.releaseExclusiveWriteAccess();
                }
            }
          };
      
      try
      {
          _coordinator.acquireExclusiveWriteAccess(runnable);
      }
      catch(AccessDeniedException e)
      {
          _coordinator.accessDenied(e);
      }
      catch(Ice.LocalException e)
      {
          JOptionPane.showMessageDialog(
            _coordinator.getMainFrame(),
            e.toString(),
            "Communication Exception",
            JOptionPane.ERROR_MESSAGE);
      }
    }

    public void saveToFile()
    {
      File file = _coordinator.saveToFile(true, this, _file);
      if(file != null)
      {
          _file = file;
          _live = false;

          _coordinator.removeLiveApplication(_id);
          _coordinator.getMainPane().resetIcon(this);

          commit();
          _coordinator.getSaveAction().setEnabled(false);
          _coordinator.getDiscardUpdatesAction().setEnabled(false);
      }
    }

    public void discardUpdates()
    {
      ApplicationDescriptor desc = null;

      if(_live)
      {
          desc = _coordinator.getLiveDeploymentRoot().getApplicationDescriptor(_id);
          assert desc != null;
          desc = IceGridGUI.Application.Root.copyDescriptor(desc);
      }
      else if(_file != null)
      {
          desc = _coordinator.parseFile(_file);
          if(desc == null)
          {
            return;
          }
      }
      else
      {
          assert false;
      }

      Root newRoot = new Root(_coordinator, desc, _live, _file);
      ApplicationPane app = _coordinator.getMainPane().findApplication(this);
      assert app != null;
      app.setRoot(newRoot);
      
      TreeNode node = newRoot.findNodeLike(_tree.getSelectionPath(), false);
      if(node == null)
      {
          newRoot.setSelectedNode(newRoot);
      }
      else
      {
          newRoot.setSelectedNode(node);
      }
      _coordinator.getCurrentTab().selected();
    }

    private void liveReset()
    {
      _live = true;
      _file = null;
      _coordinator.getMainPane().resetIcon(this);
    }


    private ApplicationUpdateDescriptor createUpdateDescriptor()
    {
      ApplicationUpdateDescriptor update = new ApplicationUpdateDescriptor();
      update.name = _descriptor.name;
      if(_editable.isModified())
      {
          //
          // Diff description
          //
          if(!_descriptor.description.equals(_origDescription))
          {
            update.description = 
                new IceGrid.BoxedString(_descriptor.description);
          }

          //
          // Diff variables
          //
          update.variables = new java.util.TreeMap(_descriptor.variables);
          java.util.List removeVariables = new java.util.LinkedList();

          java.util.Iterator p = _origVariables.entrySet().iterator();
          while(p.hasNext())
          {
            java.util.Map.Entry entry = (java.util.Map.Entry)p.next();
            Object key = entry.getKey();
            Object newValue =  update.variables.get(key);
            if(newValue == null)
            {
                removeVariables.add(key);
            }
            else
            {
                Object value = entry.getValue();
                if(newValue.equals(value))
                {
                  update.variables.remove(key);
                }
            }
          }
          update.removeVariables = (String[])removeVariables.toArray(new String[0]);

          //
          // Diff distribution
          //
          if(!_descriptor.distrib.equals(_origDistrib))
          {
            update.distrib = new IceGrid.BoxedDistributionDescriptor(
                _descriptor.distrib);
          }
      }
      else
      {
          update.variables = new java.util.TreeMap();
          update.removeVariables = new String[0];
      }

      //
      // Property sets
      //
      update.removePropertySets = _propertySets.getEditable().
          removedElements(PropertySet.class);
      update.propertySets = _propertySets.getUpdates();

      //
      // Replica Groups
      //
      update.removeReplicaGroups = _replicaGroups.getEditable().
          removedElements(ReplicaGroup.class);
      update.replicaGroups = _replicaGroups.getUpdates();
      
      //
      // Server Templates
      //
      update.removeServerTemplates = _serverTemplates.getEditable().
          removedElements(ServerTemplate.class);
      update.serverTemplates = _serverTemplates.getUpdates();

      //
      // Service Templates
      //
      update.removeServiceTemplates = _serviceTemplates.getEditable().
          removedElements(ServiceTemplate.class);
      update.serviceTemplates =_serviceTemplates.getUpdates();

      //
      // Nodes
      //
      update.removeNodes = _nodes.getEditable().
          removedElements(Node.class);
      update.nodes = _nodes.getUpdates();


      //
      // Return null if nothing changed
      //
      if(!_editable.isModified() &&
         update.removePropertySets.length == 0 &&
         update.propertySets.size() == 0 &&
         update.removeReplicaGroups.length == 0 &&
         update.replicaGroups.size() == 0 &&
         update.removeServerTemplates.length == 0 &&
         update.serverTemplates.size() == 0 &&
         update.removeServiceTemplates.length == 0 &&
         update.serviceTemplates.size() == 0 &&
         update.removeNodes.length == 0 &&
         update.nodes.size() == 0)
      {
          return null;
      }
      else
      {
          return update;
      }
    }

    private void commit()
    {
      _updated = false;
      _registryUpdatesEnabled = true;
      _canUseUpdateDescriptor = true;

      assert _concurrentUpdates.size() == 0;

      _editable.commit();
      _origVariables = _descriptor.variables;
      _origDescription = _descriptor.description;
      _origDistrib = (DistributionDescriptor)_descriptor.distrib.clone();
      
      _nodes.commit();
      _propertySets.commit();
      _replicaGroups.commit();
      _serverTemplates.commit();
      _serviceTemplates.commit();
    }

    public boolean isEphemeral()
    {
      return false;
    }

    public void destroy()
    {
      if(!_live && _file == null)
      {
          _coordinator.getMainPane().removeApplication(this);
      }
      else if(_live)
      {
          int confirm = JOptionPane.showConfirmDialog(
            _coordinator.getMainFrame(),
            "You are about to remove application '" + _id + "' from the IceGrid registry. "
            + "Do you want to proceed?", 
            "Remove Confirmation",
            JOptionPane.YES_NO_OPTION);

          if(confirm == JOptionPane.YES_OPTION)
          {
            _coordinator.removeApplicationFromRegistry(_id);
            _discardMe = true;
          }
      }
      else
      {
          assert _file != null;

          int confirm = JOptionPane.showConfirmDialog(
            _coordinator.getMainFrame(),
            "You are about to remove application '" + _id + "' and its associated file. "
            + "Do you want to proceed?", 
            "Remove Confirmation",
            JOptionPane.YES_NO_OPTION);

          if(confirm == JOptionPane.YES_OPTION)
          {
            if(_file.delete())
            {
                _coordinator.getMainPane().removeApplication(this);
            }
          }
      }
    }

    public boolean update(ApplicationUpdateDescriptor desc)
    {
      assert _live == true;
      
      if(_skipUpdates > 0)
      {
          _skipUpdates--;
          return false;
      }

      if(!_registryUpdatesEnabled)
      {
          if(_updated)
          {
            _canUseUpdateDescriptor = false;
          }
          else
          {
            _concurrentUpdates.add(desc);
          }
          return false;
      }

      try
      {
          //
          // Description
          //
          if(desc.description != null)
          {
            _descriptor.description = desc.description.value;
            _origDescription = _descriptor.description;
          }
          
          //
          // Variables
          //
          for(int i = 0; i < desc.removeVariables.length; ++i)
          {
            _descriptor.variables.remove(desc.removeVariables[i]);
          }
          _descriptor.variables.putAll(desc.variables);
          
          //
          // Distrib
          //
          if(desc.distrib != null)
          {
            _descriptor.distrib = desc.distrib.value;
            _origDistrib = (DistributionDescriptor)_descriptor.distrib.clone();
          }
          
          //
          // Property Sets
          //
          for(int i = 0; i < desc.removePropertySets.length; ++i)
          {
            _descriptor.propertySets.remove(desc.removePropertySets[i]);
          }
          _descriptor.propertySets.putAll(desc.propertySets);
          _propertySets.update(desc.propertySets, 
                         desc.removePropertySets);

          //
          // Replica groups
          //
          for(int i = 0; i < desc.removeReplicaGroups.length; ++i)
          {
            _descriptor.replicaGroups.remove(desc.
                                     removeReplicaGroups[i]);
          }
          _descriptor.replicaGroups.addAll(desc.replicaGroups);
          _replicaGroups.update(desc.replicaGroups, 
                          desc.removeReplicaGroups);
          
          
          //
          // Service templates
          //
          for(int i = 0; i < desc.removeServiceTemplates.length; ++i)
          {
            _descriptor.serviceTemplates.remove(desc.
                                        removeServiceTemplates[i]);
          }
          _descriptor.serviceTemplates.putAll(desc.serviceTemplates);
          _serviceTemplates.update(desc.serviceTemplates, 
                             desc.removeServiceTemplates);
          
          //
          // Server templates
          //
          for(int i = 0; i < desc.removeServerTemplates.length; ++i)
          {
            _descriptor.serverTemplates.remove(desc.removeServerTemplates[i]);
          }
          _descriptor.serverTemplates.putAll(desc.serverTemplates);
          _serverTemplates.update(desc.serverTemplates, 
                            desc.removeServerTemplates,
                            desc.serviceTemplates.keySet());
          
          //
          // Nodes
          //
          for(int i = 0; i < desc.removeNodes.length; ++i)
          {
            _descriptor.nodes.remove(desc.removeNodes[i]);
          }
          
          //
          // Updates also _descriptor.nodes
          //
          _nodes.update(desc.nodes, desc.removeNodes,
                    desc.serverTemplates.keySet(),
                    desc.serviceTemplates.keySet());
      }
      catch(UpdateFailedException e)
      {
          //
          // Received invalid update from IceGrid registry: a bug!
          //
          assert false;
      }

      return true;
    }

    public JTree getTree()
    {
      return _tree;
    }

    public DefaultTreeModel getTreeModel()
    {
      return _treeModel;
    }

    public Coordinator getCoordinator()
    {
      return _coordinator;
    }

    public boolean isSelectionListenerEnabled()
    {
      return _selectionListenerEnabled;
    }

    public void enableSelectionListener()
    {
      _selectionListenerEnabled = true;
    }

    public void disableSelectionListener()
    {
      _selectionListenerEnabled = false;
    }

    public void cancelEdit()
    {
      if(!_updated)
      {
          _registryUpdatesEnabled = true;

          //
          // Apply now any delayed concurrent update
          //
          java.util.Iterator p = _concurrentUpdates.iterator();
          while(p.hasNext())
          {
            ApplicationUpdateDescriptor d = (ApplicationUpdateDescriptor)p.next();
            boolean ok = update(d);
            assert ok;
          }
          _concurrentUpdates.clear();
      }
    }

    public boolean kill()
    {
      _live = false;

      if(_registryUpdatesEnabled || _discardMe)
      {
          return true;
      }
      else
      {
          _coordinator.getMainPane().resetIcon(this);
          _coordinator.getCurrentTab().selected(); // only needed when 'this' 
                                                   // corresponds to the current tab
          return false;
      }
    }

    public boolean isLive()
    {
      return _live;
    }

    public boolean hasFile()
    {
      return _file != null;
    }

    public boolean needsSaving()
    {
      return _updated;
    }

    Editor getEditor(Class c, TreeNode node)
    {
      Editor result = (Editor)_editorMap.get(c);
      if(result == null)
      {
          result = node.createEditor();
          _editorMap.put(c, result);
      }
      return result;
    }

    Object getDescriptor()
    {
      return _descriptor;
    }

    ApplicationDescriptor saveDescriptor()
    {
      ApplicationDescriptor clone = (ApplicationDescriptor)_descriptor.clone();
      clone.distrib = (IceGrid.DistributionDescriptor)clone.distrib.clone();
      return clone;
    }

    void restoreDescriptor(ApplicationDescriptor clone)
    {
      _descriptor.name = clone.name;
      _descriptor.variables = clone.variables;
      _descriptor.distrib.icepatch = clone.distrib.icepatch;
      _descriptor.distrib.directories = clone.distrib.directories;
      _descriptor.description = clone.description;
    }

    public void write(XMLWriter writer) throws java.io.IOException
    {
      writer.writeStartTag("icegrid");

      java.util.List attributes = new java.util.LinkedList();
      attributes.add(createAttribute("name", _id));

      writer.writeStartTag("application", attributes);

      if(_descriptor.description.length() > 0)
      {
          writer.writeElement("description", _descriptor.description);
      }
      writeVariables(writer, _descriptor.variables);
      writeDistribution(writer, _descriptor.distrib);

      _serviceTemplates.write(writer);
      _serverTemplates.write(writer);
      _replicaGroups.write(writer);
      _propertySets.write(writer);
      _nodes.write(writer);
      
      writer.writeEndTag("application");
      writer.writeEndTag("icegrid");
    }

    //
    // Methods called by editors; see also cancelEdit() above
    //
    void disableRegistryUpdates()
    {
      _registryUpdatesEnabled = false;
    }

    void updated()
    {
      _updated = true;
      _registryUpdatesEnabled = false; // can be true before that when updated() is called by destroy()

      _concurrentUpdates.clear();
      
      _coordinator.getSaveAction().setEnabled(_live || _file != null);
      _coordinator.getDiscardUpdatesAction().setEnabled(_live || _file != null);

      _coordinator.getSaveToRegistryAction().setEnabled(_coordinator.getSession() != null);
      _coordinator.getSaveToFileAction().setEnabled(true);
    }

  
    void rebuild() throws UpdateFailedException
    {
      Utils.Resolver oldResolver = _resolver;
      String oldId = _id;
      _id = _descriptor.name;
      _resolver = new Utils.Resolver(_descriptor.variables);
      _resolver.put("application", _id);

      try
      {
          _nodes.rebuild();
      }
      catch(UpdateFailedException e)
      {
          _id = oldId;
          _resolver = oldResolver;
          throw e;
      }
    }
    
    //
    // Called when a server-template is deleted, to remove all
    // corresponding instances.
    //
    void removeServerInstances(String templateId)
    {
      _nodes.removeServerInstances(templateId);
    }

    //
    // Called when a service-template is deleted, to remove all
    // corresponding instances
    //
    void removeServiceInstances(String templateId)
    {
      _nodes.removeServiceInstances(templateId);
      _serverTemplates.removeServiceInstances(templateId);
    }


    ServerTemplate findServerTemplate(String id)
    {
      return (ServerTemplate)_serverTemplates.findChild(id);
    }

    ServiceTemplate findServiceTemplate(String id)
    {
      return (ServiceTemplate)_serviceTemplates.findChild(id);
    }

    ReplicaGroup findReplicaGroup(String id)
    {
      return (ReplicaGroup)_replicaGroups.findChild(id);
    }

    Node findNode(String id)
    {
      return (Node)_nodes.findChild(id);
    }

    java.util.List findServerInstances(String template)
    {
      return _nodes.findServerInstances(template);
    }

    java.util.List findServiceInstances(String template)
    {
      java.util.List result = _serverTemplates.findServiceInstances(template);
      result.addAll(_nodes.findServiceInstances(template));
      return result;
    }

    TemplateDescriptor findServerTemplateDescriptor(String templateName)
    {
      return (TemplateDescriptor)
          _descriptor.serverTemplates.get(templateName);
    }

    TemplateDescriptor findServiceTemplateDescriptor(String templateName)
    {
      return (TemplateDescriptor)
          _descriptor.serviceTemplates.get(templateName);
    }
    
    ServerTemplates getServerTemplates()
    {
      return _serverTemplates;
    }
    
    ServiceTemplates getServiceTemplates()
    {
      return _serviceTemplates;
    }

    ReplicaGroups getReplicaGroups()
    {
      return _replicaGroups;
    }

    Root getRoot()
    {
      return this;
    }
    
    Utils.Resolver getResolver()
    {
      return _resolver;
    }

    //
    // Should only be used for reading
    //
    java.util.Map getVariables()
    {
      return _descriptor.variables;
    }

    private boolean isSelected()
    {
      if(_coordinator.getCurrentTab() instanceof ApplicationPane)
      {
          return ((ApplicationPane)_coordinator.getCurrentTab()).getRoot() == Root.this;
      }
      else
      {
          return false;
      }
    }

    private Coordinator _coordinator;

    //
    // 'this' is the root of the tree
    //
    private JTree _tree;
    private DefaultTreeModel _treeModel;
    private Utils.Resolver _resolver;

    private boolean _live;

    //
    // null when this application is not tied to a file 
    //
    private File _file;
    
    private ApplicationDescriptor _descriptor;

    //
    // Keeps original version (as shallow copies) to be able to build 
    // ApplicationUpdateDescriptor. Only used when _live == true
    //
    private java.util.Map _origVariables;
    private String _origDescription;
    private DistributionDescriptor _origDistrib;

    //
    // When this application (and children) is being updated, we
    // no longer apply updates from the registry. Only meaningful when
    // _live == true
    //
    private boolean _registryUpdatesEnabled = true;

    private boolean _discardMe = false;

    //
    // True when any update was applies to this application 
    // (including children)
    //
    private boolean _updated = false;
    
    //
    // Updates saved when _updated == false and 
    // _registryUpdatesEnabled == false
    //
    private java.util.List _concurrentUpdates = new java.util.LinkedList();

    //
    // When _live is true and _canUseUpdateDescriptor is true, we can
    // save the updates using an ApplicationUpdateDescriptor
    //
    private boolean _canUseUpdateDescriptor = true;
    //
    // Updates to skip (because already applied locally)
    //
    private int  _skipUpdates = 0;


    private Nodes _nodes;
    private PropertySets _propertySets;
    private ReplicaGroups _replicaGroups;
    private ServerTemplates _serverTemplates;
    private ServiceTemplates _serviceTemplates;

    private boolean _selectionListenerEnabled = true;

    private ApplicationEditor _editor;

    //
    // Map editor-class to Editor object
    //
    private java.util.Map _editorMap = new java.util.HashMap();

    static private DefaultTreeCellRenderer _cellRenderer;    
    static private JPopupMenu _popup;
}

Generated by  Doxygen 1.6.0   Back to index