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

Coordinator.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;

import java.util.prefs.Preferences;
import java.util.prefs.BackingStoreException;

import java.awt.BorderLayout;
import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Frame;
import java.awt.Rectangle;
import java.awt.Container;
import java.awt.Component;
import java.awt.Toolkit;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.awt.event.KeyEvent;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.File;

import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.ButtonGroup;
import javax.swing.JButton;
import javax.swing.JCheckBoxMenuItem;
import javax.swing.JComponent;
import javax.swing.JEditorPane;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JToggleButton;
import javax.swing.JToolBar;
import javax.swing.JTree;
import javax.swing.KeyStroke;
import javax.swing.SwingConstants;
import javax.swing.SwingUtilities;

import javax.swing.border.EmptyBorder;
import javax.swing.filechooser.FileFilter;

import com.jgoodies.looks.Options;
import com.jgoodies.looks.HeaderStyle;
import com.jgoodies.looks.BorderStyle;
import com.jgoodies.looks.plastic.PlasticLookAndFeel;

import IceGrid.*;

//
// This class coordinates the communications between the various objects
// that make up the IceGrid GUI.
// It also provides both the menu bar and tool bar.
//
public class Coordinator
{
    private class StatusBarI extends JPanel implements StatusBar
    {
      StatusBarI()
      {
          super(new BorderLayout());
          setBorder(new EmptyBorder(0, 13, 10, 13));

          _text = new JLabel();
          _text.setHorizontalAlignment(SwingConstants.LEFT);
          add(_text, BorderLayout.LINE_START);

          _connectedLabel = new JLabel("Working Offline");
          _connectedLabel.setHorizontalAlignment(SwingConstants.RIGHT);
          add(_connectedLabel, BorderLayout.LINE_END);
      }

      public void setText(String text)
      {
          _text.setText(text);
      }

      public void setConnected(boolean connected)
      {
          if(connected)
          {
            _connectedLabel.setText("Working Online");
          }
          else
          {
            _connectedLabel.setText("Working Offline");
          }
      }

      JLabel _connectedLabel;
      JLabel _text;
    }

    private class MenuBar extends JMenuBar
    {
      private MenuBar()
      {
          putClientProperty(Options.HEADER_STYLE_KEY, HeaderStyle.BOTH);
          putClientProperty(PlasticLookAndFeel.BORDER_STYLE_KEY, BorderStyle.SEPARATOR);

          //
          // File menu
          // 
          JMenu fileMenu = new JMenu("File");
          fileMenu.setMnemonic(java.awt.event.KeyEvent.VK_F);
          add(fileMenu);

          //
          // New sub-menu
          //
          _newMenu = new JMenu("New");
          fileMenu.add(_newMenu);
          _newMenu.add(_newApplication);
          _newMenu.add(_newApplicationWithDefaultTemplates);
          _newMenu.addSeparator();

          _newMenu.add(_appActionsForMenu.get(IceGridGUI.Application.TreeNode.NEW_ADAPTER));
          _newMenu.add(_appActionsForMenu.get(IceGridGUI.Application.TreeNode.NEW_DBENV));
          _newMenu.add(_appActionsForMenu.get(IceGridGUI.Application.TreeNode.NEW_NODE));
          _newMenu.add(_appActionsForMenu.get(IceGridGUI.Application.TreeNode.NEW_PROPERTY_SET));
          _newMenu.add(_appActionsForMenu.get(IceGridGUI.Application.TreeNode.NEW_REPLICA_GROUP));
          

          //
          // Open sub-menu
          //
          JMenu openMenu = new JMenu("Open");
          openMenu.add(_openApplicationFromFile);
          openMenu.add(_openApplicationFromRegistry);
          

          //
          // New server sub-sub-menu
          //
          _newServerMenu = new JMenu("Server");
          _newServerMenu.setEnabled(false);
          _newMenu.add(_newServerMenu);
          _newServerMenu.add(_appActionsForMenu.get(IceGridGUI.Application.TreeNode.NEW_SERVER));
          _newServerMenu.add(_appActionsForMenu.get(IceGridGUI.Application.TreeNode.NEW_SERVER_ICEBOX));
          _newServerMenu.add(_appActionsForMenu.get(IceGridGUI.Application.TreeNode.NEW_SERVER_FROM_TEMPLATE));
          
          //
          // New service sub-sub-menu
          //
          _newServiceMenu = new JMenu("Service");
          _newServiceMenu.setEnabled(false);
          _newMenu.add(_newServiceMenu);
          _newServiceMenu.add(_appActionsForMenu.get(IceGridGUI.Application.TreeNode.NEW_SERVICE));
          _newServiceMenu.add(_appActionsForMenu.get(IceGridGUI.Application.TreeNode.NEW_SERVICE_FROM_TEMPLATE));

          //
          // New template sub-sub-menu
          //
          _newTemplateMenu = new JMenu("Template");
          _newTemplateMenu.setEnabled(false);
          _newMenu.add(_newTemplateMenu);
          _newTemplateMenu.add(_appActionsForMenu.get(IceGridGUI.Application.TreeNode.NEW_TEMPLATE_SERVER));
          _newTemplateMenu.add(_appActionsForMenu.get(IceGridGUI.Application.TreeNode.NEW_TEMPLATE_SERVER_ICEBOX));
          _newTemplateMenu.add(_appActionsForMenu.get(IceGridGUI.Application.TreeNode.NEW_TEMPLATE_SERVICE));
          
          fileMenu.addSeparator();
          fileMenu.add(_login);
          fileMenu.add(_logout);
          fileMenu.addSeparator();
          fileMenu.add(_acquireExclusiveWriteAccess);
          fileMenu.add(_releaseExclusiveWriteAccess);
          fileMenu.addSeparator();
          fileMenu.add(openMenu);
          fileMenu.add(_closeApplication);
          fileMenu.add(_save);
          fileMenu.add(_saveToFile);
          fileMenu.add(_saveToRegistry);
          fileMenu.addSeparator();
          fileMenu.add(_discardUpdates);
          fileMenu.addSeparator();
          fileMenu.add(_exit);
         
          //
          // Edit menu
          //
          JMenu editMenu = new JMenu("Edit");
          editMenu.setMnemonic(java.awt.event.KeyEvent.VK_E);
          add(editMenu);
          editMenu.add(_appActionsForMenu.get(IceGridGUI.Application.TreeNode.COPY));
          editMenu.add(_appActionsForMenu.get(IceGridGUI.Application.TreeNode.PASTE));
          editMenu.addSeparator();
          editMenu.add(_appActionsForMenu.get(IceGridGUI.Application.TreeNode.DELETE));
          editMenu.addSeparator();
          editMenu.add(_appActionsForMenu.get(IceGridGUI.Application.TreeNode.MOVE_UP));
          editMenu.add(_appActionsForMenu.get(IceGridGUI.Application.TreeNode.MOVE_DOWN));

          //
          // View menu
          //
          JMenu viewMenu = new JMenu("View");
          viewMenu.setMnemonic(java.awt.event.KeyEvent.VK_V);
          add(viewMenu);
          viewMenu.add(_showVarsMenuItem);
          viewMenu.add(_substituteMenuItem);
          viewMenu.addSeparator();
          viewMenu.add(_back);
          viewMenu.add(_forward);

          //
          // Tools menu
          //
          JMenu toolsMenu = new JMenu("Tools");
          toolsMenu.setMnemonic(java.awt.event.KeyEvent.VK_T);
          add(toolsMenu);
          
          //
          // Application sub-menu
          //
          _appMenu = new JMenu("Application");
          _appMenu.setEnabled(false);
          toolsMenu.add(_appMenu);
          _appMenu.add(_patchApplication);
          _appMenu.setEnabled(false);
       
          //
          // Node sub-menu
          //
          _nodeMenu = new JMenu("Node");
          _nodeMenu.setEnabled(false);
          toolsMenu.add(_nodeMenu);
          _nodeMenu.add(_liveActionsForMenu.get(IceGridGUI.LiveDeployment.TreeNode.SHUTDOWN_NODE));

          //
          // Registry sub-menu
          //
          _registryMenu = new JMenu("Registry");
          _registryMenu.setEnabled(false);
          toolsMenu.add(_registryMenu);
          _registryMenu.add(_liveActionsForMenu.get(IceGridGUI.LiveDeployment.TreeNode.ADD_OBJECT));

          //
          // Server sub-menu
          //
          _serverMenu = new JMenu("Server");
          _serverMenu.setEnabled(false);
          toolsMenu.add(_serverMenu);
          _serverMenu.add(_liveActionsForMenu.get(IceGridGUI.LiveDeployment.TreeNode.START));
          _serverMenu.add(_liveActionsForMenu.get(IceGridGUI.LiveDeployment.TreeNode.STOP));
          _serverMenu.addSeparator();
          _serverMenu.add(_liveActionsForMenu.get(IceGridGUI.LiveDeployment.TreeNode.ENABLE));
          _serverMenu.add(_liveActionsForMenu.get(IceGridGUI.LiveDeployment.TreeNode.DISABLE));
          _serverMenu.addSeparator();
          _serverMenu.add(_liveActionsForMenu.get(
                        IceGridGUI.LiveDeployment.TreeNode.PATCH_SERVER));

          //
          // Help menu
          //
          JMenu helpMenu = new JMenu("Help");
          helpMenu.setMnemonic(java.awt.event.KeyEvent.VK_H);
          add(helpMenu);

          helpMenu.add(_helpContents);
          
          helpMenu.addSeparator();
          helpMenu.add(_about);
      }
    }
   
    private class ToolBar extends JToolBar
    {
      private ToolBar()
      {
          putClientProperty(Options.HEADER_STYLE_KEY, HeaderStyle.BOTH);
          putClientProperty(PlasticLookAndFeel.BORDER_STYLE_KEY, BorderStyle.SEPARATOR);
          setFloatable(false);
          putClientProperty("JToolBar.isRollover", Boolean.TRUE);

          JButton button = new JButton(_login);
          button.setText(null);
          button.setIcon(Utils.getIcon("/icons/24x24/login.png"));
          add(button);
          button = new JButton(_logout);
          button.setText(null);
          button.setIcon(Utils.getIcon("/icons/24x24/logout.png"));
          add(button);

          addSeparator();
                
          button = new JButton(_back);
          button.setText(null);
          button.setIcon(Utils.getIcon("/icons/24x24/back.png"));
          add(button);
          button = new JButton(_forward);
          button.setText(null);
          button.setIcon(Utils.getIcon("/icons/24x24/forward.png"));
          add(button);

          addSeparator();
          
          button = new JButton(_openApplicationFromRegistry);
          button.setText(null);
          button.setIcon(Utils.getIcon("/icons/24x24/open_from_registry.png"));
          add(button);
          button = new JButton(_openApplicationFromFile);
          button.setText(null);
          button.setIcon(Utils.getIcon("/icons/24x24/open_from_file.png"));
          add(button);

          addSeparator();

          button = new JButton(_save);
          button.setText(null);
          button.setIcon(Utils.getIcon("/icons/24x24/save.png"));
          add(button);
          button = new JButton(_saveToRegistry);
          button.setText(null);
          button.setIcon(Utils.getIcon("/icons/24x24/save_to_registry.png"));
          add(button);
          button = new JButton(_saveToFile);
          button.setText(null);
          button.setIcon(Utils.getIcon("/icons/24x24/save_to_file.png"));
          add(button);
          button = new JButton(_discardUpdates);
          button.setText(null);
          button.setIcon(Utils.getIcon("/icons/24x24/discard.png"));
          add(button);

          addSeparator();

          button = new JButton(_appActionsForMenu.get(IceGridGUI.Application.TreeNode.COPY));
          button.setText(null);
          button.setIcon(Utils.getIcon("/icons/24x24/copy.png"));
          add(button);
          button = new JButton(_appActionsForMenu.get(IceGridGUI.Application.TreeNode.PASTE));
          button.setText(null);
          button.setIcon(Utils.getIcon("/icons/24x24/paste.png"));
          add(button);
          button = new JButton(_appActionsForMenu.get(IceGridGUI.Application.TreeNode.DELETE));
          button.setText(null);
          button.setIcon(Utils.getIcon("/icons/24x24/delete.png"));
          add(button);

          addSeparator();

          add(_showVarsTool);
          add(_substituteTool);
      }
    }

    //
    // All Coordinator's methods run in the UI thread
    //
    public Ice.Communicator getCommunicator()
    {
      if(_communicator == null)
      {
          try
          {
            _communicator = Ice.Util.initialize(_initData);
          }
          catch(Ice.LocalException e)
          {
            JOptionPane.showMessageDialog(null,
                                    e.toString(),
                                    "Communicator initialization failed",
                                    JOptionPane.ERROR_MESSAGE);
          }
      }
      return _communicator;
    }

    public Ice.Properties getProperties()
    {
      return _initData.properties;
    }

    public Tab getCurrentTab()
    {
      return (Tab)_mainPane.getSelectedComponent();
    }
    
    public Action getBackAction()
    {
      return _back;
    }

    public Action getForwardAction()
    {
      return _forward;
    }

    public Action getCloseApplicationAction()
    {
      return _closeApplication;
    }

    public Action getSaveAction()
    {
      return _save;
    }

    public Action getSaveToRegistryAction()
    {
      return _saveToRegistry;
    }

    public Action getSaveToFileAction()
    {
      return _saveToFile;
    }

    public Action getDiscardUpdatesAction()
    {
      return _discardUpdates;
    }
    
    //
    // Open live application and select application tab
    //
    public ApplicationPane openLiveApplication(String applicationName)
    {
      ApplicationPane app = (ApplicationPane)_liveApplications.get(applicationName);
      if(app == null)
      {
          ApplicationDescriptor desc = 
            _liveDeploymentRoot.getApplicationDescriptor(applicationName);
          if(desc == null)
          {
            JOptionPane.showMessageDialog(
                _mainFrame,
                "The application '" + applicationName + "' was not found in the registry.",
                "No such application",
                JOptionPane.ERROR_MESSAGE);
          }
          //
          // Essential: deep-copy desc!
          //
          desc = IceGridGUI.Application.Root.copyDescriptor(desc);
          app = new ApplicationPane(new IceGridGUI.Application.Root(this, desc, true, null));
          _mainPane.addApplication(app);
          _liveApplications.put(applicationName, app);
      }
      _mainPane.setSelectedComponent(app);
      return app;
    }
    
    public void removeLiveApplication(String name)
    {
      _liveApplications.remove(name);
    }
    
    public void addLiveApplication(IceGridGUI.Application.Root root)
    {
      ApplicationPane app = _mainPane.findApplication(root);
      assert app != null;
      _liveApplications.put(app.getRoot().getId(), app);
    }

    public ApplicationPane getLiveApplication(String name)
    {
      return (ApplicationPane)_liveApplications.get(name);
    }


    //
    // From the Registry observer:
    //
    void registryInit(String instanceName, int serial, java.util.List applications,
                  AdapterInfo[] adapters, ObjectInfo[] objects)
    { 
      assert _latestSerial == -1;
      _latestSerial = serial;

      _liveDeploymentRoot.init(instanceName, applications, adapters, objects);
      //
      // When we get this init, we can't have any live Application yet.
      //
    }

    void applicationAdded(int serial, ApplicationDescriptor desc)
    {
      _liveDeploymentRoot.applicationAdded(desc);
      _statusBar.setText(
          "Last update: new application '" + desc.name + "'");
      updateSerial(serial);
    }

    void applicationRemoved(int serial, String name)
    {
      _liveDeploymentRoot.applicationRemoved(name);
      _statusBar.setText(
          "Last update: application '" + name + "' was removed");

      ApplicationPane app = 
          (ApplicationPane)_liveApplications.get(name);
      
      if(app != null)
      {
          if(app.getRoot().kill())
          {
            _mainPane.remove(app);
          }
          _liveApplications.remove(name);
      }
      updateSerial(serial);
    }

    void applicationUpdated(int serial, ApplicationUpdateDescriptor desc)
    {
      _liveDeploymentRoot.applicationUpdated(desc);
      _liveDeploymentPane.refresh();

      _statusBar.setText("Last update: application  '" + desc.name + "' was updated");
      
      ApplicationPane app =
          (ApplicationPane)_liveApplications.get(desc.name);

      if(app != null)
      {
          if(app.getRoot().update(desc))
          {
            app.refresh();
          }
      }
      updateSerial(serial);
    }

    void adapterAdded(int serial, AdapterInfo info)
    {
      _liveDeploymentRoot.adapterAdded(info);
      _liveDeploymentPane.refresh();
      updateSerial(serial);
    }    

    void adapterUpdated(int serial, AdapterInfo info)
    {
      _liveDeploymentRoot.adapterUpdated(info);
      _liveDeploymentPane.refresh();
      updateSerial(serial);
    }    

    void adapterRemoved(int serial, String id)
    {
      _liveDeploymentRoot.adapterRemoved(id);
      _liveDeploymentPane.refresh();
      updateSerial(serial);
    }    
    
    void objectAdded(int serial, ObjectInfo info)
    {
      _liveDeploymentRoot.objectAdded(info);
      _liveDeploymentPane.refresh();
      updateSerial(serial);
    }    

    void objectUpdated(int serial, ObjectInfo info)
    {
      _liveDeploymentRoot.objectUpdated(info);
      _liveDeploymentPane.refresh();
      updateSerial(serial);
    }    

    void objectRemoved(int serial, Ice.Identity id)
    {
      _liveDeploymentRoot.objectRemoved(id);
      _liveDeploymentPane.refresh();
      updateSerial(serial);
    } 
    
    public void accessDenied(AccessDeniedException e)
    {
      JOptionPane.showMessageDialog(
          _mainFrame,
          "Another session (username = " + e.lockUserId 
          + ") has exclusive write access to the registry",
          "Access Denied",
          JOptionPane.ERROR_MESSAGE);
    }

    public void pasteApplication()
    {
      Object descriptor = getClipboard();
      ApplicationDescriptor desc = 
          IceGridGUI.Application.Root.copyDescriptor((ApplicationDescriptor)descriptor);

      IceGridGUI.Application.Root root = new IceGridGUI.Application.Root(this, desc);
      ApplicationPane app = new ApplicationPane(root);
      _mainPane.addApplication(app);
      _mainPane.setSelectedComponent(app);
      root.setSelectedNode(root);
    }
    
    public void removeApplicationFromRegistry(String name)
    {
      _mainFrame.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
      
      boolean acquired = false;
      try
      {
          acquireExclusiveWriteAccess(null);
          acquired = true;
          _sessionKeeper.getAdmin().removeApplication(name);
      }
      catch(AccessDeniedException e)
      {
          accessDenied(e);
      }
      catch(ApplicationNotExistException e)
      {
          //
          // Somebody else deleted this application at about the same time
          //
      }
      catch(Ice.LocalException e)
      {
          JOptionPane.showMessageDialog(
            _mainFrame,
            "Could not remove application '" + name + 
            "' from IceGrid registry:\n" + e.toString(),
            "Trouble with IceGrid registry",
            JOptionPane.ERROR_MESSAGE);
      }
      finally
      {
          if(acquired)
          {
            releaseExclusiveWriteAccess();
          }
          _mainFrame.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
      }
    }

    public void acquireExclusiveWriteAccess(Runnable runnable)
      throws AccessDeniedException
    {
      if(_writeSerial == -1)
      {
          _mainFrame.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
          try
          {
            _writeSerial = _sessionKeeper.getSession().startUpdate();
          }
          finally
          {
            _mainFrame.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
          }
      }

      assert _onExclusiveWrite == null;

      //
      // Must increment now since run() can call releaseExclusiveWriteAccess()
      //
      _writeAccessCount++;

      if(runnable != null)
      {
          if(_writeSerial <= _latestSerial)
          {
            runnable.run();
          }
          else
          {
            _onExclusiveWrite = runnable;
            _mainFrame.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
            //
            // TODO: start a thread to check we don't wait forever
            //
          }
      }
    }

    public void releaseExclusiveWriteAccess()
    {
      if(--_writeAccessCount == 0)
      {
          try
          {
            _writeSerial = -1;
            _sessionKeeper.getSession().finishUpdate();
          }
          catch(AccessDeniedException e)
          {
            accessDenied(e);
          }
          catch(Ice.ObjectNotExistException e)
          {
            //
            // Ignored, the session is gone, and so is the exclusive access.
            //
          }
          catch(Ice.LocalException e)
          {
            JOptionPane.showMessageDialog(
                _mainFrame,
                "Could not release exclusive write access on the IceGrid registry:\n"
                + e.toString(),
                "Trouble with IceGrid registry",
                JOptionPane.ERROR_MESSAGE);
          }
      }
    }

    private void updateSerial(int serial)
    {
      assert serial == _latestSerial + 1;
      _latestSerial = serial;
      
      if(_writeAccessCount > 0 && 
         _writeSerial <= _latestSerial &&
         _onExclusiveWrite != null)
      {
          Runnable runnable = _onExclusiveWrite;
          _onExclusiveWrite = null;
          runnable.run();
          _mainFrame.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
      }
    }
  
    //
    // From the Node observer:
    //
    void nodeUp(NodeDynamicInfo updatedInfo)
    {
      _liveDeploymentRoot.nodeUp(updatedInfo);
      _liveDeploymentPane.refresh();
    }

    void nodeDown(String node)
    {
      _liveDeploymentRoot.nodeDown(node);
      _liveDeploymentPane.refresh();
    }

    void updateServer(String node, ServerDynamicInfo updatedInfo)
    {
      _liveDeploymentRoot.updateServer(node, updatedInfo);
      _liveDeploymentPane.refresh();
    }

    void updateAdapter(String node, AdapterDynamicInfo updatedInfo)
    {
      _liveDeploymentRoot.updateAdapter(node, updatedInfo);
      _liveDeploymentPane.refresh();
    }
    
    void sessionLost()
    {
      _latestSerial = -1;
      _writeSerial = -1;
      _writeAccessCount = 0;
      _onExclusiveWrite = null;
      _liveDeploymentRoot.clear();

      //
      // Kill all live applications
      //
      java.util.Iterator p = _liveApplications.values().iterator();
      while(p.hasNext())
      {
          ApplicationPane app = (ApplicationPane)p.next();
          if(app.getRoot().kill())
          {
            _mainPane.remove(app);
          }
      }
      _liveApplications.clear();
      
      _logout.setEnabled(false);
      _openApplicationFromRegistry.setEnabled(false);
      _patchApplication.setEnabled(false);
      _appMenu.setEnabled(false);
      _newApplicationWithDefaultTemplates.setEnabled(false);
      _acquireExclusiveWriteAccess.setEnabled(false);
      _releaseExclusiveWriteAccess.setEnabled(false);
      _saveToRegistry.setEnabled(false);
    }
    
    AdminSessionPrx login(SessionKeeper.LoginInfo info, Component parent)
    { 
      _liveDeploymentRoot.clear();

      AdminSessionPrx session = null;
      
      destroyCommunicator();

      Ice.InitializationData initData = _initData;    
      if(info.routed && info.routerSSLEnabled || !info.routed && info.registrySSLEnabled)
      {
          initData = (Ice.InitializationData)initData.clone();
          initData.properties = initData.properties._clone();
          initData.properties.setProperty("Ice.Plugin.IceSSL", "IceSSL.PluginFactory");

          //
          // Transform SSL info into properties
          //         
          initData.properties.setProperty("IceSSL.Keystore", info.keystore);
          initData.properties.setProperty("IceSSL.Password", new String(info.keyPassword));
          initData.properties.setProperty("IceSSL.KeystorePassword", new String(info.keystorePassword));
          initData.properties.setProperty("IceSSL.Alias", info.alias);
          initData.properties.setProperty("IceSSL.Truststore", info.truststore);
          initData.properties.setProperty("IceSSL.TruststorePassword", new String(info.truststorePassword));
      }

      try
      {
          _communicator = Ice.Util.initialize(initData);
      }
      catch(Ice.LocalException e)
      {
          JOptionPane.showMessageDialog(parent,
                                e.toString(),
                                "Communicator initialization failed",
                                JOptionPane.ERROR_MESSAGE);
          return null;
      }

      if(info.routed)
      {
          //
          // Router
          //
          
          Ice.Identity id = new Ice.Identity();
          id.category = info.routerInstanceName;
          id.name = "router";
          String str = "\"" + _communicator.identityToString(id) + "\"";
          if(!info.routerEndpoints.equals(""))
          {
            str += ":" + info.routerEndpoints;
          }
          
          try
          {
            Glacier2.RouterPrx router = Glacier2.RouterPrxHelper.
                uncheckedCast(_communicator.stringToProxy(str));

            //
            // The session must be routed through this router
            //
            _communicator.setDefaultRouter(router);

            Glacier2.SessionPrx s;
            if(info.routerUseSSL)
            {
                router = Glacier2.RouterPrxHelper.
                  uncheckedCast(router.ice_secure(true));

                s = router.createSessionFromSecureConnection();
                
                if(s == null)
                {
                  JOptionPane.showMessageDialog(
                      parent,
                      "createSessionFromSecureConnection returned a null session: \n"
                      + "verify that Glacier2.SSLSessionManager is set to "
                      + "<IceGridInstanceName>/AdminSSLSessionManager in your Glacier2 router configuration",
                      "Login failed",
                      JOptionPane.ERROR_MESSAGE);
                  
                  return null;
                }
            }
            else
            {
                s = router.createSession(
                  info.routerUsername, new String(info.routerPassword));

                if(s == null)
                {
                  JOptionPane.showMessageDialog(
                      parent,
                      "createSession returned a null session: \n"
                      + "verify that Glacier2.SessionManager is set to "
                      + "<IceGridInstanceName>/AdminSessionManager in your Glacier2 router configuration",
                      "Login failed",
                      JOptionPane.ERROR_MESSAGE);
                  
                  return null;
                }
            }
            
            session = AdminSessionPrxHelper.uncheckedCast(s);
          }
          catch(Glacier2.PermissionDeniedException e)
          {
            if(e.reason.length() == 0)
            {
                e.reason = info.routerUseSSL ? "Invalid credentials" : "Invalid username/password";
            }
            JOptionPane.showMessageDialog(parent,
                                    "Permission denied: "
                                    + e.reason,
                                    "Login failed",
                                    JOptionPane.ERROR_MESSAGE);
            return null;
          }
          catch(Glacier2.CannotCreateSessionException e)
          {
            JOptionPane.showMessageDialog(parent,
                                    "Could not create session: "
                                    + e.reason,
                                    "Login failed",
                                    JOptionPane.ERROR_MESSAGE);
            return null;
          }
          catch(Ice.LocalException e)
          {
            JOptionPane.showMessageDialog(parent,
                                    "Could not create session: "
                                    + e.toString(),
                                    "Login failed",
                                    JOptionPane.ERROR_MESSAGE);
            return null;
          }
      }
      else
      {
          //
          // The client uses the locator only without routing
          //
          Ice.Identity locatorId = new Ice.Identity();
          locatorId.category = info.registryInstanceName;
          locatorId.name = "Locator";
          String str = "\"" + _communicator.identityToString(locatorId) + "\"";
          if(!info.registryEndpoints.equals(""))
          {
            str += ":" + info.registryEndpoints;
          }
         
          try
          {
            Ice.LocatorPrx defaultLocator = Ice.LocatorPrxHelper.
                checkedCast(_communicator.stringToProxy(str));
            _communicator.setDefaultLocator(defaultLocator);
          }
          catch(Ice.LocalException e)
          {
            JOptionPane.showMessageDialog(
                parent,
                "Could not contact '" + str + "': " + e.toString(),
                "Login failed",
                JOptionPane.ERROR_MESSAGE);
            return null;
          }

          //
          // Local session
          //
          Ice.Identity registryId = new Ice.Identity();
          registryId.category = info.registryInstanceName;
          registryId.name = "Registry";
            
          RegistryPrx registry = RegistryPrxHelper.
            uncheckedCast(_communicator.stringToProxy("\"" + _communicator.identityToString(registryId) + "\""));
          
          try
          {
            if(info.registryUseSSL)
            {
                registry = RegistryPrxHelper.
                  uncheckedCast(registry.ice_secure(true));

                session = AdminSessionPrxHelper.uncheckedCast(
                  registry.createAdminSessionFromSecureConnection());
            }
            else
            {
                session = AdminSessionPrxHelper.uncheckedCast(
                  registry.createAdminSession(info.registryUsername, 
                                        new String(info.registryPassword)));
            }
          }
          catch(IceGrid.PermissionDeniedException e)
          {
            JOptionPane.showMessageDialog(parent,
                                    "Permission denied: "
                                    + e.reason,
                                    "Login failed",
                                    JOptionPane.ERROR_MESSAGE);
            return null;
          }
          catch(Ice.LocalException e)
          {
            JOptionPane.showMessageDialog(parent,
                                    "Could not create session: "
                                    + e.toString(),
                                    "Login failed",
                                    JOptionPane.ERROR_MESSAGE);
            return null;
          }
      }
      
      _logout.setEnabled(true);
      _openApplicationFromRegistry.setEnabled(true);
      _patchApplication.setEnabled(true);
      _appMenu.setEnabled(true);
      _newApplicationWithDefaultTemplates.setEnabled(true);
      _acquireExclusiveWriteAccess.setEnabled(true);

      _mainPane.setSelectedComponent(_liveDeploymentPane);

      return session;
    }

    
    void destroySession(AdminSessionPrx session)
    {
      Ice.RouterPrx router = _communicator.getDefaultRouter();

      try
      {
          if(router == null)
          {
            session.destroy();
          }
          else
          {
            Glacier2.RouterPrx gr 
                = Glacier2.RouterPrxHelper.uncheckedCast(router);
            gr.destroySession();
          }
      }
      catch(Glacier2.SessionNotExistException e)
      {
          // Ignored
      }
      catch(Ice.LocalException e)
      {
          // Ignored
      }
    }

    void showVars()
    {
      substitute(false);
    }

    void substituteVars()
    {
      substitute(true);
    }

    private void substitute(boolean newValue)
    {
      if(_substitute != newValue)
      {
          _substitute = newValue;

          if(_substitute)
          {
            _substituteMenuItem.setSelected(true);
            _substituteTool.setSelected(true);
          }
          else
          {
            _showVarsMenuItem.setSelected(true);
            _showVarsTool.setSelected(true);
          }
          getCurrentTab().refresh();
      }
    }

    public boolean substitute()
    {
      return _substitute;
    }

    public AdminPrx getAdmin()
    {
      return _sessionKeeper.getAdmin();
    }

    public StatusBar getStatusBar()
    {
      return _statusBar;
    }

    public JFrame getMainFrame()
    {
      return _mainFrame;
    }

    public MainPane getMainPane()
    {
      return _mainPane;
    }

    public ApplicationDescriptor parseFile(File file)
    {
      if(_icegridadminProcess == null)
      {
          //
          // Start icegridadmin server
          //
          try
          {
            _icegridadminProcess = Runtime.getRuntime().exec("icegridadmin --server");
          }
          catch(java.io.IOException e)
           {
            JOptionPane.showMessageDialog(
                _mainFrame,
                "Failed to start icegridadmin subprocess: " + e.toString(),
                "IO Exception",
                JOptionPane.ERROR_MESSAGE);
            return null;
          }
          
          try
          {
            BufferedReader reader = 
                new BufferedReader(new InputStreamReader(_icegridadminProcess.getInputStream(),
                                               "US-ASCII"));
            
            String str = reader.readLine();
            reader.close();

            if(str == null || str.length() == 0)
            {
                JOptionPane.showMessageDialog(
                  _mainFrame,
                  "The icegridadmin subprocess failed",
                  "Subprocess failure",
                  JOptionPane.ERROR_MESSAGE);
                destroyIceGridAdmin();
                return null;
            }
            _fileParser = str;
          }
          catch(java.io.UnsupportedEncodingException e)
          {
            assert false;
          }
          catch(java.io.IOException e)
          {
            JOptionPane.showMessageDialog(
                _mainFrame,
                "IO Exception: " + e.toString(),
                "IO Exception",
                JOptionPane.ERROR_MESSAGE);

            destroyIceGridAdmin();
            return null;
          }
      }

      try
      {
          FileParserPrx fileParser = FileParserPrxHelper.checkedCast(
            getCommunicator().stringToProxy(_fileParser).ice_router(null));
          return fileParser.parse(file.getAbsolutePath(), 
                            _sessionKeeper.getRoutedAdmin());
      }
      catch(ParseException e)
      {
          JOptionPane.showMessageDialog(
            _mainFrame,
            "Failed to parse file '" + file.getAbsolutePath() + "':\n" + e.toString(),
            "Parse error",
            JOptionPane.ERROR_MESSAGE);
          return null;
      }
      catch(Ice.LocalException e)
      {
          JOptionPane.showMessageDialog(
            _mainFrame,
            "Operation on FileParser failed:\n" + e.toString(),
            "Communication error",
            JOptionPane.ERROR_MESSAGE);
          destroyIceGridAdmin();
          return null;
      }
    }

    private void destroyIceGridAdmin()
    {
      if(_icegridadminProcess != null)
      {
          try
          {
            _icegridadminProcess.destroy();
          }
          catch(Exception e)
          {}
          _icegridadminProcess = null;
          _fileParser = null;
      }
    }


    public File saveToFile(boolean ask, IceGridGUI.Application.Root root,
                     File file)
    {
      if(ask || file == null)
      {
          if(file != null)
          {
            _fileChooser.setSelectedFile(file);
          }
          int result = _fileChooser.showSaveDialog(_mainFrame);
          if(result == JFileChooser.APPROVE_OPTION)
          {
            file = _fileChooser.getSelectedFile();
          }
          else
          {
            file = null;
          }
      }
      if(file != null)
      {
          try
          {
            XMLWriter writer = new XMLWriter(file);
            root.write(writer);
            writer.close();
            _statusBar.setText(
                "Saved application '" + root.getId() + "' to "
                + file.getAbsolutePath());
          }
          catch(java.io.FileNotFoundException e)
          {
            JOptionPane.showMessageDialog(
                _mainFrame,
                "Cannot use the selected file for writing.",
                "File Not Found",
                JOptionPane.ERROR_MESSAGE);
            return null;
          }
          catch(java.io.IOException e)
          {
            JOptionPane.showMessageDialog(
                _mainFrame,
                "IO Exception: " + e.toString(),
                "IO Exception",
                JOptionPane.ERROR_MESSAGE);
            return null;
          }
      }
      return file;
    }

    
    static private Ice.Properties createProperties(Ice.StringSeqHolder args)
    {
      Ice.Properties properties = Ice.Util.createProperties();
      
      //
      // Set various default values
      //
      properties.setProperty("Ice.Override.ConnectTimeout", "5000");
      
      properties.setProperty("Ice.ThreadPerConnection", "1");

      //
      // For Glacier
      //
      properties.setProperty("Ice.ACM.Client", "0");
      properties.setProperty("Ice.MonitorConnections", "5");
      
      //
      // Disable retries
      //
      properties.setProperty("Ice.RetryIntervals", "-1");
      
      return Ice.Util.createProperties(args, properties);
    }

    Coordinator(JFrame mainFrame, Ice.StringSeqHolder args, Preferences prefs)
    { 
      _mainFrame = mainFrame;
      _prefs = prefs;
      _initData = new Ice.InitializationData();

      _initData.properties = createProperties(args);
      
      if(args.value.length > 0)
      {
          //
          // TODO: use proper logging
          //
          System.err.println("WARNING: extra command-line arguments");
          for(int i = 0; i < args.value.length; ++i)
          {
            System.err.println(args.value[i]);
          }
      }

      _liveDeploymentRoot = new IceGridGUI.LiveDeployment.Root(this);

      _sessionKeeper = new SessionKeeper(this);

      _shutdownHook = new Thread("Shutdown hook")
          {
            public void run()
            {
                destroyIceGridAdmin();
                destroyCommunicator();
            }
          };
      Runtime.getRuntime().addShutdownHook(_shutdownHook);

      _fileChooser = new JFileChooser();
      _fileChooser.addChoosableFileFilter(new FileFilter()
          {
            public boolean accept(File f)
            {
                return f.isDirectory() || f.getName().endsWith(".xml");
            }
            
            public String getDescription()
            {
                return ".xml files";
            }
          });


      final int MENU_MASK = Toolkit.getDefaultToolkit().getMenuShortcutKeyMask();

      //
      // Common actions (nodes not involved)
      //
      _newApplication = new AbstractAction("Application")
          {
            public void actionPerformed(ActionEvent e) 
            {
                newApplication();
            }
          };

      _newApplicationWithDefaultTemplates = 
          new AbstractAction("Application with default templates from registry")
          {
            public void actionPerformed(ActionEvent e) 
            {
                newApplicationWithDefaultTemplates();
            }
          };
      _newApplicationWithDefaultTemplates.setEnabled(false);

      _login = new AbstractAction("Login...")
          {
            public void actionPerformed(ActionEvent e) 
            {
                _sessionKeeper.relog(true);
            }
          };
      _login.putValue(Action.SHORT_DESCRIPTION, 
                  "Log into an IceGrid registry");

      _logout = new AbstractAction("Logout")
          {
            public void actionPerformed(ActionEvent e) 
            {
                _sessionKeeper.logout(true);
            }
          };
      _logout.putValue(Action.SHORT_DESCRIPTION, "Logout");
      _logout.setEnabled(false);

      _acquireExclusiveWriteAccess = new AbstractAction("Acquire exclusive write access")
          {
            public void actionPerformed(ActionEvent e) 
            {
                try
                {
                  acquireExclusiveWriteAccess(null);
                  _releaseExclusiveWriteAccess.setEnabled(true);
                  _acquireExclusiveWriteAccess.setEnabled(false);
                }
                catch(AccessDeniedException ade)
                {
                  accessDenied(ade);
                }
            }
          };
      _acquireExclusiveWriteAccess.putValue(Action.SHORT_DESCRIPTION, 
                                    "Acquire exclusive write access on the registry");
      _acquireExclusiveWriteAccess.setEnabled(false);

      
      _releaseExclusiveWriteAccess = new AbstractAction("Release exclusive write access")
          {
            public void actionPerformed(ActionEvent e) 
            {
                releaseExclusiveWriteAccess();
                _acquireExclusiveWriteAccess.setEnabled(true);
                _releaseExclusiveWriteAccess.setEnabled(false);
            }
          };
      _releaseExclusiveWriteAccess.putValue(Action.SHORT_DESCRIPTION, 
                                    "Release exclusive write access on the registry");
      _releaseExclusiveWriteAccess.setEnabled(false);

      _openApplicationFromFile = new AbstractAction("Application from file")
          {
            public void actionPerformed(ActionEvent e) 
            {
                int result = _fileChooser.showOpenDialog(_mainFrame);
                if(result == JFileChooser.APPROVE_OPTION)
                {
                  File file = _fileChooser.getSelectedFile();

                  ApplicationDescriptor desc = parseFile(file);

                  if(desc != null)
                  {
                      IceGridGUI.Application.Root root = 
                        new IceGridGUI.Application.Root(Coordinator.this, desc, false, file);
                      ApplicationPane app = new ApplicationPane(root);
                      _mainPane.addApplication(app);
                      _mainPane.setSelectedComponent(app);
                      root.setSelectedNode(root);
                  }
                }
            }
          };
      _openApplicationFromFile.putValue(Action.SHORT_DESCRIPTION, "Open application from file");
      _openApplicationFromFile.setEnabled(true);
      
      _openApplicationFromRegistry = new AbstractAction("Application from registry")
          {
            public void actionPerformed(ActionEvent e) 
            {
                Object[] applicationNames = _liveDeploymentRoot.getApplicationNames();
                
                if(applicationNames.length == 0)
                {
                  JOptionPane.showMessageDialog(
                      _mainFrame,
                      "The registry does not contain any application",
                      "Empty registry",
                      JOptionPane.INFORMATION_MESSAGE);
                }
                else
                {
                  String appName = (String)JOptionPane.showInputDialog(
                      _mainFrame, "Which Application do you want to open?", 
                      "Open Application from registry",      
                      JOptionPane.QUESTION_MESSAGE, null,
                      applicationNames, applicationNames[0]);
                  
                  if(appName != null)
                  {
                      IceGridGUI.Application.Root root = openLiveApplication(appName).getRoot();
                      if(root.getSelectedNode() == null)
                      {
                        root.setSelectedNode(root);
                      }
                  }
                }
            }
          };
      _openApplicationFromRegistry.putValue(Action.SHORT_DESCRIPTION, "Open application from registry");
      _openApplicationFromRegistry.setEnabled(false);

      _closeApplication = new AbstractAction("Close application")
          {
            public void actionPerformed(ActionEvent e) 
            {
                Tab tab = getCurrentTab();
                if(tab.close())
                {
                  String id = ((ApplicationPane)tab).getRoot().getId();
                  _liveApplications.remove(id);
                }
            }
          };
      _closeApplication.putValue(Action.SHORT_DESCRIPTION, "Close application");
      _closeApplication.setEnabled(false);

      _save = new AbstractAction("Save")
          {
            public void actionPerformed(ActionEvent e) 
            {
                getCurrentTab().save();
            }
          };
      _save.setEnabled(false);
      _save.putValue(Action.ACCELERATOR_KEY, 
                   KeyStroke.getKeyStroke(KeyEvent.VK_S, MENU_MASK));
      _save.putValue(Action.SHORT_DESCRIPTION, "Save");

      
      _saveToRegistry = new AbstractAction("Save to registry")
          {
            public void actionPerformed(ActionEvent e) 
            {
                getCurrentTab().saveToRegistry();
            }
          };
      _saveToRegistry.setEnabled(false);
      _saveToRegistry.putValue(Action.SHORT_DESCRIPTION, "Save to registry");

      
      _saveToFile = new AbstractAction("Save to file")
          {
            public void actionPerformed(ActionEvent e) 
            {
                getCurrentTab().saveToFile();
            }
          };
      _saveToFile.setEnabled(false);
      _saveToFile.putValue(Action.SHORT_DESCRIPTION, "Save to file");

      
      _discardUpdates = new AbstractAction("Discard updates...")
          {
            public void actionPerformed(ActionEvent e) 
            {
                getCurrentTab().discardUpdates();
            }
          };
      _discardUpdates.setEnabled(false);
      _discardUpdates.putValue(Action.SHORT_DESCRIPTION, "Discard updates");


      _exit = new AbstractAction("Exit")
          {
            public void actionPerformed(ActionEvent e) 
            {
                exit(0);
            }
          };
      _exit.putValue(Action.ACCELERATOR_KEY, KeyStroke.getKeyStroke("alt F4"));


      _back = new AbstractAction("Go back to the previous node")
          {
            public void actionPerformed(ActionEvent e) 
            {
                getCurrentTab().back();
            }
          };
      _back.setEnabled(false);
      _back.putValue(Action.SHORT_DESCRIPTION, "Go back to the previous node");

      _forward =  new AbstractAction("Go to the next node")
          {
            public void actionPerformed(ActionEvent e) 
            {
                getCurrentTab().forward();
            }
          };
      _forward.setEnabled(false);
      _forward.putValue(Action.SHORT_DESCRIPTION, "Go to the next node");

      _helpContents = new AbstractAction("Contents")
          {
            public void actionPerformed(ActionEvent e) 
            {
                helpContents();
            }     
          };
      
      _about = new AbstractAction("About")
          {
            public void actionPerformed(ActionEvent e) 
            {
                about();
            }
          };
      
      _patchApplication = new AbstractAction("Patch distribution")
          {
            public void actionPerformed(ActionEvent e) 
            {
                Object[] applicationNames = _liveDeploymentRoot.getPatchableApplicationNames();
                
                if(applicationNames.length == 0)
                {
                  JOptionPane.showMessageDialog(
                      _mainFrame,
                      "No application in this IceGrid registry can be patched",
                      "No application",
                      JOptionPane.INFORMATION_MESSAGE);
                }
                else
                {
                  String appName = (String)JOptionPane.showInputDialog(
                      _mainFrame, "Which Application do you want to patch?", 
                      "Patch application",       
                      JOptionPane.QUESTION_MESSAGE, null,
                      applicationNames, applicationNames[0]);
                  
                  if(appName != null)
                  {
                      _liveDeploymentRoot.patch(appName);
                  }
                }
            }
          };
      _patchApplication.setEnabled(false);

      _showVarsMenuItem = new
          JCheckBoxMenuItem(_appActionsForMenu.get(IceGridGUI.Application.TreeNode.SHOW_VARS));
      _showVarsTool = new 
          JToggleButton(_appActionsForMenu.get(IceGridGUI.Application.TreeNode.SHOW_VARS));
      _showVarsTool.setIcon(Utils.getIcon("/icons/24x24/show_vars.png"));
      _showVarsTool.setText("");

      _substituteMenuItem = new
          JCheckBoxMenuItem(_appActionsForMenu.get(IceGridGUI.Application.TreeNode.SUBSTITUTE_VARS));
      _substituteTool = new 
          JToggleButton(_appActionsForMenu.get(IceGridGUI.Application.TreeNode.SUBSTITUTE_VARS));
      _substituteTool.setIcon(Utils.getIcon("/icons/24x24/substitute.png"));
      _substituteTool.setText("");


      ButtonGroup group = new ButtonGroup();
      group.add(_showVarsMenuItem);
      group.add(_substituteMenuItem);
      group = new ButtonGroup();
      group.add(_showVarsTool);
      group.add(_substituteTool);

      _showVarsMenuItem.setSelected(true);
      _showVarsTool.setSelected(true);

      _mainFrame.setJMenuBar(new MenuBar());

      _mainFrame.getContentPane().add(new ToolBar(),
                              BorderLayout.PAGE_START);
 
      _mainFrame.getContentPane().add((StatusBarI)_statusBar, 
                              BorderLayout.PAGE_END);

      _liveDeploymentPane = new LiveDeploymentPane(_liveDeploymentRoot);
      _mainPane = new MainPane(this);
      _mainFrame.getContentPane().add(_mainPane, BorderLayout.CENTER);  
    }

    JComponent getLiveDeploymentPane()
    {
      return _liveDeploymentPane;
    }
    
    public IceGridGUI.LiveDeployment.Root getLiveDeploymentRoot()
    {
      return _liveDeploymentRoot;
    }

    private void newApplication()
    {
      ApplicationDescriptor desc =  new ApplicationDescriptor("NewApplication",
                                                 new java.util.TreeMap(),
                                                 new java.util.LinkedList(),
                                                 new java.util.HashMap(),
                                                 new java.util.HashMap(),
                                                 new java.util.HashMap(),
                                                 new IceGrid.DistributionDescriptor(
                                                     "", new java.util.LinkedList()),
                                                "",
                                                new java.util.HashMap());
      IceGridGUI.Application.Root root = new IceGridGUI.Application.Root(this, desc);
      ApplicationPane app = new ApplicationPane(root);
      _mainPane.addApplication(app);
      _mainPane.setSelectedComponent(app);
      root.setSelectedNode(root);
    }

    private void newApplicationWithDefaultTemplates()
    {
      _mainFrame.setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
      try
      {
          ApplicationDescriptor descriptor = getAdmin().getDefaultApplicationDescriptor();
          descriptor.name = "NewApplication";
          IceGridGUI.Application.Root root = new IceGridGUI.Application.Root(this, descriptor);
          ApplicationPane app = new ApplicationPane(root);
          _mainPane.addApplication(app);
          _mainPane.setSelectedComponent(app);
          root.setSelectedNode(root);
      }
      catch(DeploymentException e)
      {
          JOptionPane.showMessageDialog(
            _mainFrame,
            "The default application descriptor from the IceGrid registry is invalid:\n"
            + e.reason,
            "Deployment Exception",
            JOptionPane.ERROR_MESSAGE);
      }
      catch(Ice.LocalException e)
      {
          JOptionPane.showMessageDialog(
            _mainFrame,
            "Could not retrieve the default application descriptor from the IceGrid registry: \n"
            + e.toString(),
            "Trouble with IceGrid registry",
            JOptionPane.ERROR_MESSAGE);
      }
      finally
      {
          _mainFrame.setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
      }
    }

    private void helpContents()
    {
      BareBonesBrowserLaunch.openURL(
          "http://www.zeroc.com/help/IceGridAdmin/");
    }

    private void about()
    {
      String text = "IceGrid Admin version " 
          + IceUtil.Version.ICE_STRING_VERSION + "\n"
          + "Copyright \u00A9 2005-2006 ZeroC, Inc. All rights reserved.\n";
          
      JOptionPane.showMessageDialog(
          _mainFrame,
          text,
          "About - IceGrid Admin",
          JOptionPane.INFORMATION_MESSAGE);
    }

    public void setClipboard(Object copy)
    {
      _clipboard = copy;
    }

    public Object getClipboard()
    {
      return _clipboard; 
    }

    void showMainFrame()
    {
      if(!loadWindowPrefs())
      {
          _mainFrame.setLocation(100, 100);
          _mainFrame.pack();
      }
      _mainFrame.setVisible(true);
    }

    void exit(int status)
    {
      storeWindowPrefs();
      destroyIceGridAdmin();
      destroyCommunicator();
      Runtime.getRuntime().removeShutdownHook(_shutdownHook);
      _mainFrame.dispose();
      Runtime.getRuntime().exit(status);
    }
    
    //
    // Can be called by the shutdown hook thread
    //
    private void destroyCommunicator()
    {
      if(_communicator != null)
      {
          try        
          {
            _communicator.destroy();
          }
          catch(Ice.LocalException e)
          {
            System.err.println("_communicator.destroy() raised "
                           + e.toString());
            e.printStackTrace();
          }
          _communicator = null;
      }
    }

    private boolean loadWindowPrefs()
    {
      try
      {
          if(!_prefs.nodeExists("Window"))
          {
            return false;
          }
      }
      catch(BackingStoreException e)
      {
          return false;
      }

      Preferences windowPrefs = _prefs.node("Window");
      int x = windowPrefs.getInt("x", 0);
      int y = windowPrefs.getInt("y", 0);
      int width = windowPrefs.getInt("width", 0);
      int height = windowPrefs.getInt("height", 0);
      _mainFrame.setBounds(new Rectangle(x, y, width, height));
      if(windowPrefs.getBoolean("maximized", false))
      {
          _mainFrame.setExtendedState(Frame.MAXIMIZED_BOTH);
      }
      return true;
    }

    private void storeWindowPrefs()
    {
      Preferences windowPrefs = _prefs.node("Window");
      Rectangle rect = _mainFrame.getBounds();
      windowPrefs.putInt("x", rect.x);
      windowPrefs.putInt("y", rect.y);
      windowPrefs.putInt("width", rect.width);
      windowPrefs.putInt("height", rect.height);
      windowPrefs.putBoolean("maximized",
                         _mainFrame.getExtendedState() == Frame.MAXIMIZED_BOTH);
    }


    public AdminSessionPrx getSession()
    {
      return _sessionKeeper.getSession();
    }

    SessionKeeper getSessionKeeper()
    {
      return _sessionKeeper;
    }

    Preferences getPrefs()
    {
      return _prefs;
    }

    public LiveActions getLiveActionsForPopup()
    {
      return _liveActionsForPopup;
    }

    public LiveActions getLiveActionsForMenu()
    {
      return _liveActionsForMenu;
    }

    public ApplicationActions getActionsForMenu()
    {
      return _appActionsForMenu;
    }

    public ApplicationActions getActionsForPopup()
    {
      return _appActionsForPopup;
    }

    public void showActions(IceGridGUI.LiveDeployment.TreeNode node)
    {
      boolean[] availableActions = _liveActionsForMenu.setTarget(node);
      _appActionsForMenu.setTarget(null);
      
      _newServerMenu.setEnabled(false);
      _newServiceMenu.setEnabled(false);    
      _newTemplateMenu.setEnabled(false);

      _appMenu.setEnabled(true);
      
      _nodeMenu.setEnabled(
          availableActions[IceGridGUI.LiveDeployment.TreeNode.SHUTDOWN_NODE]);

      _registryMenu.setEnabled(
          availableActions[IceGridGUI.LiveDeployment.TreeNode.ADD_OBJECT]);

      _serverMenu.setEnabled(
          availableActions[IceGridGUI.LiveDeployment.TreeNode.START] ||
          availableActions[IceGridGUI.LiveDeployment.TreeNode.STOP] ||
          availableActions[IceGridGUI.LiveDeployment.TreeNode.ENABLE] ||
          availableActions[IceGridGUI.LiveDeployment.TreeNode.DISABLE] ||
          availableActions[IceGridGUI.LiveDeployment.TreeNode.PATCH_SERVER]);
    }
      
    public void showActions(IceGridGUI.Application.TreeNode node)
    {
      boolean[] availableActions = _appActionsForMenu.setTarget(node);
      _liveActionsForMenu.setTarget(null);
      
      _newServerMenu.setEnabled(
          availableActions[IceGridGUI.Application.TreeNode.NEW_SERVER] ||
          availableActions[IceGridGUI.Application.TreeNode.NEW_SERVER_ICEBOX] ||
          availableActions[IceGridGUI.Application.TreeNode.NEW_SERVER_FROM_TEMPLATE]);

      _newServiceMenu.setEnabled(
          availableActions[IceGridGUI.Application.TreeNode.NEW_SERVICE] ||
          availableActions[IceGridGUI.Application.TreeNode.NEW_SERVICE_FROM_TEMPLATE]);
                          
      _newTemplateMenu.setEnabled(
          availableActions[IceGridGUI.Application.TreeNode.NEW_TEMPLATE_SERVER] ||
          availableActions[IceGridGUI.Application.TreeNode.NEW_TEMPLATE_SERVER_ICEBOX] ||
          availableActions[IceGridGUI.Application.TreeNode.NEW_TEMPLATE_SERVICE]);

      _appMenu.setEnabled(false);
      _nodeMenu.setEnabled(false);
      _registryMenu.setEnabled(false);
      _serverMenu.setEnabled(false);
    } 


    private final Ice.InitializationData _initData;
    private Ice.Communicator _communicator;

    private Preferences _prefs;
    private StatusBarI _statusBar = new StatusBarI();
    
    private IceGridGUI.LiveDeployment.Root _liveDeploymentRoot;
    private LiveDeploymentPane _liveDeploymentPane;

    //
    // Maps application-name to ApplicationPane (only for 'live' applications)
    //
    private java.util.Map _liveApplications = new java.util.HashMap();

    private MainPane _mainPane;

    //
    // Keep tracks of serial number when viewing/editing application definitions
    // (not used for displaying live deployment)
    //
    private int _latestSerial = -1;
    private int _writeSerial = -1;
   
    private Runnable _onExclusiveWrite;
    private int _writeAccessCount = 0;

    private boolean _substitute = false;
    
    private JFrame _mainFrame;
    private SessionKeeper _sessionKeeper;

    private Object _clipboard;
    
    //
    // Actions
    //
    private Action _newApplication;
    private Action _newApplicationWithDefaultTemplates;
    private Action _login;
    private Action _logout;
    private Action _acquireExclusiveWriteAccess;
    private Action _releaseExclusiveWriteAccess;

    private Action _openApplicationFromFile;
    private Action _openApplicationFromRegistry;
    private Action _closeApplication;
    private Action _save;
    private Action _saveToRegistry;
    private Action _saveToFile;
    private Action _discardUpdates;
    private Action _exit;
    private Action _back;
    private Action _forward;
    private Action _helpContents;
    private Action _about;
    private Action _patchApplication;

    //
    // Two sets of actions because the popup's target and the menu/toolbar's target
    // can be different.
    // 
    private LiveActions _liveActionsForMenu = new LiveActions();
    private LiveActions _liveActionsForPopup = new LiveActions();
    private ApplicationActions _appActionsForMenu = new ApplicationActions(false);
    private ApplicationActions _appActionsForPopup = new ApplicationActions(true);
    
    
    private JToggleButton _showVarsTool;
    private JToggleButton _substituteTool;
    private JCheckBoxMenuItem _substituteMenuItem;
    private JCheckBoxMenuItem _showVarsMenuItem;
    

    private JMenu _newMenu;
    private JMenu _newServerMenu;
    private JMenu _newServiceMenu;
    private JMenu _newTemplateMenu;
    private JMenu _appMenu;
    private JMenu _nodeMenu;
    private JMenu _registryMenu;
    private JMenu _serverMenu;

    private final Thread _shutdownHook;

    private JFileChooser _fileChooser;
    
    private Process _icegridadminProcess;
    private String _fileParser;

    static private final int HISTORY_MAX_SIZE = 20;
}

Generated by  Doxygen 1.6.0   Back to index