src/org/objectweb/cjdbc/console/gui/CjdbcGui.java

説明を見る。

package org.objectweb.cjdbc.console.gui;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Container;
import java.awt.Cursor;
import java.awt.FlowLayout;
import java.awt.GridLayout;
import java.awt.dnd.DnDConstants;
import java.awt.dnd.DropTarget;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Hashtable;

import javax.management.MBeanException;
import javax.swing.BorderFactory;
import javax.swing.JButton;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTabbedPane;
import javax.swing.JTextArea;
import javax.swing.JTextField;
import javax.swing.JTextPane;
import javax.swing.JToolTip;
import javax.swing.filechooser.FileFilter;

import org.objectweb.cjdbc.common.exceptions.CJDBCException;
import org.objectweb.cjdbc.common.i18n.GuiTranslate;
import org.objectweb.cjdbc.common.jmx.JmxException;
import org.objectweb.cjdbc.common.jmx.mbeans.ControllerMBean;
import org.objectweb.cjdbc.common.jmx.mbeans.DataCollectorMBean;
import org.objectweb.cjdbc.common.jmx.mbeans.DatabaseBackendMBean;
import org.objectweb.cjdbc.common.jmx.mbeans.VirtualDatabaseMBean;
import org.objectweb.cjdbc.common.jmx.notifications.CjdbcNotificationList;
import org.objectweb.cjdbc.common.shared.BackendInfo;
import org.objectweb.cjdbc.common.util.Constants;
import org.objectweb.cjdbc.console.gui.constants.GuiCommands;
import org.objectweb.cjdbc.console.gui.constants.GuiConstants;
import org.objectweb.cjdbc.console.gui.dnd.listeners.BackendTransferListener;
import org.objectweb.cjdbc.console.gui.dnd.listeners.ControllerTransferListener;
import org.objectweb.cjdbc.console.gui.frames.GuiExceptionFrame;
import org.objectweb.cjdbc.console.gui.frames.GuiNewControllerFrame;
import org.objectweb.cjdbc.console.gui.frames.GuiSelectCheckpoint;
import org.objectweb.cjdbc.console.gui.frames.GuiSelectShutdown;
import org.objectweb.cjdbc.console.gui.frames.GuiVirtualDatabaseLoginFrame;
import org.objectweb.cjdbc.console.gui.frames.NewBackendFrame;
import org.objectweb.cjdbc.console.gui.jtools.JMultiLineToolTip;
import org.objectweb.cjdbc.console.gui.jtools.JTextAreaWriter;
import org.objectweb.cjdbc.console.gui.objects.BackendObject;
import org.objectweb.cjdbc.console.gui.objects.ConfigurationFileObject;
import org.objectweb.cjdbc.console.gui.objects.ControllerObject;
import org.objectweb.cjdbc.console.gui.objects.DatabaseObject;
import org.objectweb.cjdbc.console.gui.objects.DumpFileObject;
import org.objectweb.cjdbc.console.gui.objects.tooltips.BackendToolTip;
import org.objectweb.cjdbc.console.gui.popups.ConfigurationFilePopUpMenu;
import org.objectweb.cjdbc.console.gui.popups.ControllerListPopUpMenu;
import org.objectweb.cjdbc.console.gui.popups.ControllerPopUpMenu;
import org.objectweb.cjdbc.console.gui.popups.DatabasePopUpMenu;
import org.objectweb.cjdbc.console.gui.popups.DumpPopUpMenu;
import org.objectweb.cjdbc.console.gui.popups.LogEditPopUpMenu;
import org.objectweb.cjdbc.console.gui.session.GuiSession;
import org.objectweb.cjdbc.console.gui.threads.GuiLoggingThread;
import org.objectweb.cjdbc.console.gui.threads.GuiParsingThread;
import org.objectweb.cjdbc.console.gui.threads.task.BackupBackendTask;
import org.objectweb.cjdbc.console.gui.threads.task.RestoreBackendTask;
import org.objectweb.cjdbc.console.jmx.ControllerJmxClient;
import org.objectweb.cjdbc.console.jmx.RmiJmxClient;
import org.objectweb.cjdbc.console.monitoring.MonitoringConsole;
import org.objectweb.cjdbc.console.views.CacheStatsViewer;
import org.objectweb.cjdbc.console.views.CacheViewer;
import org.objectweb.cjdbc.console.views.RecoveryLogViewer;
import org.objectweb.cjdbc.console.views.SQLStatViewer;

public class CjdbcGui extends JFrame
{
  // DATA CONTAINERS

  GuiSession                   guiSession;
  Hashtable                    databaseMBeans;
  Hashtable                    controllerMBeans;
  Hashtable                    backendsState;
  Hashtable                    backendList;
  Hashtable                    databaseList;
  Hashtable                    controllerList;

  Hashtable                    jmxClients;
  RmiJmxClient                 currentJmxClient;
  String                       selectedController;
  String                       selectedDatabase;

  Object                       credentials = null;

  // THREADS

  Thread                       logginThread;

  // MIXED CONTAINERS

  JPanel                       vdbListPanel;
  JPanel                       fileListPanel;
  JPanel                       controllerListPanel;

  // FLOATING FRAMES

  GuiVirtualDatabaseLoginFrame loginFrame;
  GuiNewControllerFrame        newControllerFrame;
  GuiExceptionFrame            exceptionFrame;
  NewBackendFrame              newBackendFrame;
  GuiSelectCheckpoint          selectCheckpointFrame;
  GuiSelectShutdown            selectShutdownFrame;

  // LISTENERS

  BackendTransferListener      backendTransferListener;
  ControllerTransferListener   configurationFileTransferListener;

  CjdbcGuiListener             guiActionListener;

  // GRAPHIC CONTAINERS

  String                       debugText, loggingText;
  JTextArea                    debugTextPane, loggingTextPane;
  JTextPane                    infoTextPane;
  GuiParsingThread             parsingThread;
  JTextPane                    xmlTextPane;
  JFileChooser                 configurationFileChooser;
  JFileChooser                 jarFileChooser;
  JFileChooser                 saveFileChooser;
  JPanel                       backendPanel;
  ControllerListPopUpMenu      controllerListPopUpMenu;
  JTabbedPane                  centerPane;
  JScrollPane                  helpScroll, debugScroll, xmlScroll,
      loggingScroll, infoScroll, logConfigScroll;
  JScrollPane                  fileScroll;
  JTextArea                    debugTraceTextPane;
  JTextAreaWriter              traceWriter;
  JTextPane                    logConfigTextPane;
  JPanel                       backendButtons, backendIcons;

  public CjdbcGui()
  {
    super(GuiTranslate.get("gui.name"));
    new Thread(new CjdbcGuiLoader(this)).start();
  }

  private ControllerMBean actionGETControllerBean(String controllerName)
  {
    if (controllerMBeans.containsKey(controllerName))
    {
      currentJmxClient = (RmiJmxClient) jmxClients.get(controllerName);
      if (currentJmxClient.isValidConnection())
      {
        ControllerMBean controllerMBean = (ControllerMBean) controllerMBeans
            .get(controllerName);
        return controllerMBean;
      }
      else
      {
        appendDebugText("Controller :" + controllerName
            + " cannot be accessed anymore. Trying to reconnect...");
        controllerMBeans.remove(controllerName);
        return actionGETControllerBean(controllerName);
      }
    }
    else
    {
      try
      {
        RmiJmxClient jmxClient = new RmiJmxClient(controllerName, credentials);
        appendDebugText("Setting listener for controller:" + controllerName);
        jmxClient.setNotificationListener(guiActionListener);
        jmxClients.put(controllerName, jmxClient);
        controllerMBeans.put(controllerName, jmxClient.getControllerProxy());
        if (selectedController == null
            || controllerName.equalsIgnoreCase(selectedController))
          currentJmxClient = jmxClient;

        appendDebugText("Connected to: " + controllerName);
        actionStartControllerLoggingThread(controllerName);

        return jmxClient.getControllerProxy();
      }
      catch (Exception e)
      {
        appendDebugText("Failed to connect to: " + controllerName);
        return null;
      }
    }
  }

  private void actionStartControllerLoggingThread(String controllerName)
  {
    try
    {
      ControllerJmxClient controllerMBean = (ControllerJmxClient) controllerMBeans
          .get(controllerName);
      logginThread = new Thread(new GuiLoggingThread(loggingTextPane,
          controllerMBean.getRemoteHostName()));
      logginThread.start();
      appendDebugText("Log4j logging thread started for: <" + controllerName
          + ">");
    }
    catch (Exception e1)
    {
      appendDebugText("Could not start log4j logging thread to: <"
          + controllerName + ">");
    }
  }

  private VirtualDatabaseMBean actionGETDatabaseBean(String databaseName)
  {
    if (databaseMBeans.containsKey(databaseName))
    {
      return (VirtualDatabaseMBean) databaseMBeans.get(databaseName);
    }
    else
    {
      appendDebugText("Login to database:" + databaseName);
      DatabaseObject dob = (DatabaseObject) databaseList.get(databaseName);
      loginFrame = new GuiVirtualDatabaseLoginFrame(this, guiActionListener,
          databaseName, dob.getIpAdress(), dob.getPort(), guiSession);
      loginFrame.setVisible(true);
      return null;
    }
  }

  private void actionLoadDatabaseList(String controllerName)
  {
    // Load list of database
    ControllerMBean controllerMBean = actionGETControllerBean(controllerName);
    ArrayList databases;
    try
    {
      vdbListPanel.removeAll();
      databases = controllerMBean.listVirtualDatabases();
      int size = databases.size();
      appendDebugText("Loading virtual databases list...");
      for (int i = 0; i < size; i++)
        actionLoadDatabase((String) databases.get(i), controllerName);
    }
    catch (Exception e1)
    {
      appendDebugText("Cannot load virtual database list");
      vdbListPanel.removeAll();
    }
    paintDatabasePanel();
    repaint();
  }

  void actionUnloadBackends(String controller)
  {
    appendDebugText("Unloading backends from controller:" + controller);
    Enumeration enume;
    BackendObject bo;
    String name;
    while ((enume = backendList.keys()).hasMoreElements())
    {
      name = (String) enume.nextElement();
      bo = (BackendObject) backendList.get(name);
      bo.setVisible(false);
      backendList.remove(name);
    }
  }

  void paintDatabasePanel()
  {
    vdbListPanel.validate();
    vdbListPanel.repaint();
    validate();
    repaint();
  }

  private void actionLoadDatabase(String databaseName, String controllerName)
  {
    // Load graphic object for a virtual database
    boolean isDistributed = false;
    isDistributed = actionGETControllerBean(controllerName)
        .isDistributedVirtualDatabase(databaseName);
    DatabaseObject dob = new DatabaseObject(databaseName, controllerName,
        isDistributed);
    dob.setActionCommand(GuiCommands.COMMAND_SELECT_DATABASE);
    dob.addActionListener(guiActionListener);
    dob.addMouseListener(new DatabasePopUpMenu(this, dob));
    databaseList.put(databaseName, dob);
    actionAddObjectToGridLayout(vdbListPanel, dob);
    appendDebugText("Loaded:" + databaseName + " for controller:"
        + controllerName);
  }

  private void actionAddObjectToGridLayout(JPanel panel, JButton button)
  {
    GridLayout layout = (GridLayout) panel.getLayout();
    int pcount = panel.getComponentCount();
    layout.setRows(pcount + 1);
    panel.add(button);
    panel.validate();
    panel.repaint();
  }

  public void publicActionLoadBackendsList(String databaseName)
  {
    try
    {
      VirtualDatabaseMBean databaseMBean = actionGETDatabaseBean(databaseName);
      //ArrayList list = actionLoadCheckpointNames(databaseName);
      ArrayList backends = databaseMBean.viewAllBackendNames();
      appendDebugText("Local Backend list for controller("
          + currentJmxClient.getRemoteName() + ") is:" + backends);
      for (int i = 0; i < backends.size(); i++)
        actionLoadBackend(databaseName, (String) backends.get(i),
            currentJmxClient.getRemoteName(), true);

      if (databaseMBean.isDistributed())
      {
        databaseMBean = actionGETDatabaseBean(databaseName);
        Hashtable map;
        try
        {
          map = databaseMBean.viewGroupBackends();
          Enumeration enumeration = map.keys();
          while (enumeration.hasMoreElements())
          {
            String controllerName = (String) enumeration.nextElement();
            ArrayList list = (ArrayList) map.get(controllerName);
            for (int i = 0; i < list.size(); i++)
            {
              BackendInfo info = (BackendInfo) list.get(i);
              String backendName = info.getName();
              actionLoadBackend(databaseName, backendName, controllerName,
                  false);
            }
          }
        }
        catch (RuntimeException e1)
        {
          appendDebugText(
              "Runtime exception while loading distributed database:"
                  + databaseName, e1);
        }

      }
      paintBackendPane();
    }
    catch (Exception e)
    {
      appendDebugText("Could not retrieve backend list for database"
          + databaseName, e);
    }
  }

  public void actionLoadBackend(String database, String backendName,
      String controllerName, boolean enable)
  {
    BackendObject backend = null;
    if (!backendList.containsKey(backendName))
    {
      appendDebugText("Loading backend:" + backendName + " from controller:"
          + controllerName);
      try
      {
        backend = new BackendObject(this, backendTransferListener, database,
            backendName, controllerName)
        {
          public JToolTip createToolTip()
          {
            return new JMultiLineToolTip();
          }
        };
      }
      catch (Exception e)
      {
        e.printStackTrace();
      }
      backend.setBorder(BorderFactory.createTitledBorder(
          GuiConstants.LOWERED_BORDER, controllerName));
      backend.setControllerName(controllerName);
      backendList.put(backendName, backend);
    }
    else
    {
      backend = (BackendObject) backendList.get(backendName);
      backend.setBorder(BorderFactory.createTitledBorder(
          GuiConstants.LOWERED_BORDER, controllerName));
      backend.setControllerName(controllerName);
      backend.setEnabled(controllerName.equals(selectedController));
      appendDebugText("ReLoading backend:" + backendName);
    }

    try
    {
      actionSetBackendState(backendName);
    }
    catch (RuntimeException e)
    {
      appendDebugText("cannot access mbean anymore");
      publicActionRemoveBackendFromGui(backendName);
    }
  }

  private String actionConvertState(String fromJmx)
  {
    if (fromJmx == null)
      return null;

    System.out.println(fromJmx);

    if (fromJmx
        .equalsIgnoreCase(CjdbcNotificationList.VIRTUALDATABASE_BACKEND_ENABLED))
      return GuiConstants.BACKEND_STATE_ENABLED;
    else if (fromJmx
        .equalsIgnoreCase(CjdbcNotificationList.VIRTUALDATABASE_BACKEND_ENABLED_WRITE))
      return GuiConstants.BACKEND_STATE_ENABLED;
    else if (fromJmx
        .equalsIgnoreCase(CjdbcNotificationList.VIRTUALDATABASE_BACKEND_DISABLED))
      return GuiConstants.BACKEND_STATE_DISABLED;
    else if (fromJmx
        .equalsIgnoreCase(CjdbcNotificationList.VIRTUALDATABASE_BACKEND_DISABLING))
      return GuiConstants.BACKEND_STATE_DISABLED;
    else if (fromJmx
        .equalsIgnoreCase(CjdbcNotificationList.VIRTUALDATABASE_BACKEND_BACKINGUP))
      return GuiConstants.BACKEND_STATE_BACKUP;
    else if (fromJmx
        .equalsIgnoreCase(CjdbcNotificationList.VIRTUALDATABASE_BACKEND_RECOVERING))
      return GuiConstants.BACKEND_STATE_RECOVERY;
    else
      return null;
  }

  public void actionChangeBackendState(BackendObject bo, String newState)
  {
    // test if the new state is valid
    if (!GuiConstants.isValidBackendState(newState))
      return;

    // State is valid, process

    // Removed from old panel
    String oldState = bo.getState();
    JPanel oldpanel = (JPanel) backendsState.get(oldState);
    oldpanel.remove(bo);
    oldpanel.validate();
    oldpanel.repaint();

    // Change the state of the backend object
    bo.setState(newState);

    // Add it to thew new state panel
    JPanel panel = (JPanel) backendsState.get(newState);
    panel.add(bo);
    panel.validate();
    panel.repaint();
  }

  public void actionSetBackendState(String backendName)
  {
    try
    {
      BackendObject bo = (BackendObject) backendList.get(backendName);
      String controllerName = bo.getControllerName();
      if (selectedController.equals(controllerName))
        bo.setEnabled(true);
      else
        bo.setEnabled(false);
      String state = bo.getState();
      appendDebugText("STATE:" + state);
      String login = guiSession.getAuthenticatedDatabaseLogin(bo.getDatabase());
      String password = guiSession.getAuthenticatedDatabasePassword(bo
          .getDatabase());
      RmiJmxClient client = (RmiJmxClient) jmxClients.get(controllerName);
      DatabaseBackendMBean backend = null;
      VirtualDatabaseMBean databaseMBean = null;

      try
      {
        backend = client.getDatabaseBackendProxy(bo.getDatabase(), backendName,
            login, password);
        databaseMBean = client.getVirtualDatabaseProxy(bo.getDatabase(), login,
            password);
      }
      catch (Exception e)
      {
        appendDebugText("Could not change state of backend:" + backendName,
            new JmxException("MBean connection was lost"));
      }
      String newState = actionConvertState(backend.getState());
      appendDebugText("Setting backend(" + backendName + "):"
          + backend.getName() + " to state:" + newState);

      if (state == null)
      {
        // state has not been inited
      }
      else
      {
        // remove previous state
        JPanel panel = (JPanel) backendsState.get(state);
        panel.remove(bo);
        panel.validate();
        panel.repaint();
      }

      // Set new state
      JPanel panel = (JPanel) backendsState.get(newState);
      bo.setState(newState);

      // set Tool tip after state
      try
      {
        String[] data = databaseMBean.viewBackendInformation(backendName);
        bo.setToolTipText(new BackendToolTip(data).getFormattedToolTip());
      }
      catch (Exception e)
      {
        appendDebugText("Tool tip could not be collected for backend:"
            + backendName);
      }
      panel.add(bo);
      panel.validate();
      panel.repaint();
    }
    catch (Exception e)
    {
      appendDebugText("Could not change state of backend:" + backendName, e);
    }
  }

  public void paintBackendPane()
  {
    // Paint backends panel
    backendPanel.validate();
    backendPanel.repaint();
  }

  void paintConfigurationPane()
  {
    // Paint configuration file panel
    fileScroll.setVisible(true);
    fileListPanel.setVisible(true);
    fileScroll.validate();
    fileListPanel.validate();
    fileScroll.repaint();
  }

  String actionLoadXmlText(File filePath)
  {
    // Load xml file content
    try
    {
      if (filePath == null || !filePath.exists())
      {
        return "";
      }
      StringBuffer buffer = new StringBuffer();
      BufferedReader reader = new BufferedReader(new FileReader(filePath));
      String line = "";
      while ((line = reader.readLine()) != null)
      {
        buffer.append(line + System.getProperty("line.separator"));
      }
      reader.close();
      return buffer.toString();
    }
    catch (Exception e)
    {
      appendDebugText("Error while reading from file:" + e.getMessage());
      return "";
    }
  }

  public void appendDebugText(String text)
  {
    debugText += text + System.getProperty("line.separator");
    debugTextPane.setText(debugText);
  }

  public void appendDebugText(String text, Exception e)
  {
    try
    {
      if (GuiConstants.DEBUG_LEVEL <= GuiConstants.DEBUG_NO_EXCEPTION_WINDOW)
      {
        if (e instanceof MBeanException)
          exceptionFrame.showException(((MBeanException) e)
              .getTargetException());
        else
          exceptionFrame.showException(e);
      }
      appendDebugText(text + "[Message:" + e.getMessage() + "]");
      traceWriter.write("---- Exception ----\n");
      e.printStackTrace(new PrintWriter(traceWriter));
      traceWriter.flush();
    }
    catch (IOException e1)
    {
      // ignore . . .
    }
  }

  public void publicActionAddXmlFile()
  {
    if (configurationFileChooser == null)
    {
      configurationFileChooser = new JFileChooser(".");
      configurationFileChooser.setFileFilter(new FileFilter()
      {
        public boolean accept(File f)
        {
          if (f.getAbsolutePath().endsWith(".xml") || f.isDirectory())
            return true;
          else
            return false;
        }

        public String getDescription()
        {
          return "Xml Files";
        }
      });
    }
    configurationFileChooser.showOpenDialog(this);
    File selFile = configurationFileChooser.getSelectedFile();
    if (selFile != null)
    {
      appendDebugText("Selected new file:" + selFile.getAbsolutePath());
      guiSession.addFileToConfigurationFiles(selFile);
      ConfigurationFileObject cfo = new ConfigurationFileObject(
          configurationFileTransferListener, selFile);
      ConfigurationFilePopUpMenu cfpum = new ConfigurationFilePopUpMenu(this,
          cfo);
      cfo.addActionListener(cfpum);
      cfo.addMouseListener(cfpum);
      actionAddObjectToGridLayout(fileListPanel, cfo);
      paintConfigurationPane();
    }
  }

  void actionLoadXmlList()
  {
    if (fileListPanel != null)
    {
      ArrayList vfileItems = guiSession.getConfigurationFiles();
      int vsize = vfileItems.size();
      ConfigurationFileObject cfo;
      for (int i = 0; i < vsize; i++)
      {
        cfo = new ConfigurationFileObject(configurationFileTransferListener,
            (File) vfileItems.get(i));
        ConfigurationFilePopUpMenu cfpum = new ConfigurationFilePopUpMenu(this,
            cfo);
        cfo.addActionListener(cfpum);
        cfo.addMouseListener(cfpum);
        fileListPanel.add(cfo);
        actionAddObjectToGridLayout(fileListPanel, cfo);
      }
      //paintConfigurationPane();
    }
  }

  private ArrayList actionLoadCheckpointNames(String databaseName)
  {
    ArrayList list = actionGETDatabaseBean(databaseName).viewCheckpointNames();
    for (int i = 0; i < list.size(); i++)
      appendDebugText("Found checkpoint:" + list.get(i) + " for database:"
          + databaseName);
    return list;
  }

  public void publicActionLoadControllerList()
  {
    if (controllerListPanel != null)
    {
      controllerListPanel.removeAll();
      ArrayList controllerItems = guiSession.getControllerItems();
      int size = controllerItems.size();
      for (int i = 0; i < size; i++)
        actionLoadController((String) controllerItems.get(i));
      paintControllerPane();
    }
  }

  void paintControllerPane()
  {
    controllerListPanel.validate();
    controllerListPanel.repaint();
  }

  public void publicActionAddControllerView()
  {
    newControllerFrame.setVisible(true);
  }

  public void publicActionDatabaseEnableAll(String databaseName)
  {
    try
    {
      actionGETDatabaseBean(databaseName).enableAllBackend();
      publicActionLoadBackendsList(databaseName);
      centerPane.setSelectedComponent(backendPanel);
      appendDebugText("Enabled All backends for :" + databaseName
          + " was a success");
    }
    catch (Exception e)
    {
      appendDebugText("Enabled All backends for :" + databaseName + " failed",
          e);
    }
  }

  public void actionLoadBackendActionButton(String name)
  {
    // Define backend action buttons
    appendDebugText("Loading backend action panel:" + name);
    Color color = GuiConstants.getBackendBgColor(name);

    JPanel paneContent = new JPanel(new FlowLayout());
    paneContent.setBackground(color);
    paneContent.setName(name);
    paneContent.setVisible(true);

    JButton paneLabel = new JButton(name);
    paneLabel.setActionCommand(name);
    paneLabel.setBackground(color);
    paneLabel.setSize(100, 50);
    paneLabel.setVisible(true);

    DropTarget target1 = new DropTarget(paneLabel, DnDConstants.ACTION_MOVE,
        backendTransferListener);
    target1.setActive(true);

    DropTarget target2 = new DropTarget(paneContent, DnDConstants.ACTION_MOVE,
        backendTransferListener);
    target2.setActive(true);

    GridLayout iconLayout = (GridLayout) backendIcons.getLayout();
    iconLayout.setColumns(iconLayout.getColumns() + 1);
    GridLayout buttonsLayout = (GridLayout) backendButtons.getLayout();
    buttonsLayout.setColumns(buttonsLayout.getColumns() + 1);
    backendIcons.add(paneContent);
    backendButtons.add(paneLabel);
    // Adding to the main hashtable of states
    backendsState.put(name, paneContent);
  }

  public void actionLoadBackendPane(boolean recoveryEnabled)
  {
    // Define backend panel
    if (backendPanel == null)
    {
      backendPanel = new JPanel(new BorderLayout());
      backendPanel.setEnabled(true);
      backendPanel.setBackground(Color.white);
      backendPanel.setVisible(true);
    }
    else
    {
      backendPanel.remove(backendButtons);
      backendPanel.remove(backendIcons);
    }

    backendButtons = new JPanel(new GridLayout(1, 0));
    backendIcons = new JPanel(new GridLayout(1, 0));
    backendIcons.setBackground(Color.white);
    backendIcons.setVisible(true);
    backendButtons.setVisible(true);

    actionLoadBackendActionButton(GuiConstants.BACKEND_STATE_ENABLED);
    if (recoveryEnabled)
      actionLoadBackendActionButton(GuiConstants.BACKEND_STATE_RECOVERY);
    actionLoadBackendActionButton(GuiConstants.BACKEND_STATE_DISABLED);
    if (recoveryEnabled)
      actionLoadBackendActionButton(GuiConstants.BACKEND_STATE_BACKUP);
    if (recoveryEnabled)
      actionLoadBackendActionButton(GuiConstants.BACKEND_STATE_RESTORE);
    backendPanel.add(backendIcons, BorderLayout.CENTER);
    backendPanel.add(backendButtons, BorderLayout.NORTH);

    centerPane.validate();
    centerPane.repaint();
    validate();
    repaint();
  }

  public void publicActionLoadAuthenticatedDatabase()
  {
    loginFrame.setVisible(false);
    try
    {
      String databaseName = loginFrame.getDatabaseName();
      String login = loginFrame.getLoginBox().getText().trim();
      String password = loginFrame.getPasswordBox().getText().trim();

      VirtualDatabaseMBean mbean = currentJmxClient.getVirtualDatabaseProxy(
          databaseName, login, password);

      if (!mbean.checkAdminAuthentication(login, password))
      {
        throw new Exception("Authentication failed");
      }

      databaseMBeans.put(databaseName, mbean);
      guiSession.addDatabaseToSession(databaseName, login, password);

      String[] list = mbean.viewControllerList();
      for (int i = 0; i < list.length; i++)
      {
        appendDebugText("Found controllerL" + list[i]);
        if (!guiSession.checkControllerInSession(list[i]))
        {
          actionLoadController(list[i]);
          RmiJmxClient client = (RmiJmxClient) jmxClients.get(list[i]);
          // get the listeners on the virtual database
          client.getVirtualDatabaseProxy(databaseName, login, password);
          paintControllerPane();
        }
      }

      boolean recoveryExist = mbean.hasRecoveryLog();
      appendDebugText("RecoveryLog is defined for this database:"
          + recoveryExist);
      actionLoadBackendPane(recoveryExist);

      publicActionLoadBackendsList(databaseName);
      actionLoadCheckpointNames(databaseName);
      publicActionLoadDumpList(currentJmxClient.getRemoteName());

    }
    catch (Exception e1)
    {
      appendDebugText("Could not connect to database", e1);
    }
  }

  public void publicActionQuit()
  {
    try
    {
      guiSession.saveSessionToFile(new File(
          GuiConstants.CJDBC_DEFAULT_SESSION_FILE));
    }
    catch (IOException e)
    {
      System.out.println("Could not save session");
    }
    System.exit(0);
  }

  public void publicActionLoadDriver(String controllerName)
  {
    if (jarFileChooser == null)
    {
      jarFileChooser = new JFileChooser(".");
      jarFileChooser.setFileFilter(new FileFilter()
      {
        public boolean accept(File f)
        {
          if (f.getAbsolutePath().endsWith(".jar") || f.isDirectory())
            return true;
          else
            return false;
        }

        public String getDescription()
        {
          return "Jar Files";
        }
      });
    }
    jarFileChooser.showOpenDialog(this);
    File selFile = jarFileChooser.getSelectedFile();
    try
    {
      if (selFile != null)
      {
        ControllerMBean controllerMBean = actionGETControllerBean(controllerName);
        controllerMBean.addDriver(selFile.getAbsolutePath());
      }
    }
    catch (Exception e)
    {
      appendDebugText("Could not load driver from jar file:"
          + selFile.getName());
    }
  }

  public void publicActionRefreshLogs(String controllerName)
  {
    try
    {
      ControllerMBean controllerMBean = actionGETControllerBean(controllerName);
      loggingTextPane.setText(controllerMBean.generateLogReport());
      appendDebugText("Re-Fetched logs for controller:" + controllerName);
    }
    catch (Exception e)
    {
      appendDebugText("Fail to fetch logs for controller:" + controllerName, e);
    }
  }

  public void publicActionCleanDebugBuffer()
  {
    debugText = "";
    debugTextPane.setText("");
  }

  public void publicActionSaveConfigurationFile()
  {
    try
    {
      if (saveFileChooser == null)
      {
        saveFileChooser = new JFileChooser();
        saveFileChooser.showSaveDialog(this);
        File selected = saveFileChooser.getSelectedFile();
        if (selected != null)
        {
          BufferedWriter writer = new BufferedWriter(new FileWriter(selected));
          writer.write(xmlTextPane.getText());
          writer.close();
        }
        else
        {
          appendDebugText("Did not select a file was saving...");
        }
      }
    }
    catch (Exception e)
    {
      appendDebugText("Error while writing to file:" + e.getMessage());
    }
  }

  public void publicActionAddController()
  {
    newControllerFrame.setVisible(false);
    String ipAddress = newControllerFrame.getIpAddressBox().getText().trim();
    String port = newControllerFrame.getPortNumber().getText().trim();
    appendDebugText("Add controller with ip:" + ipAddress + " amd port:" + port);
    String name = ipAddress + ":" + port;
    if (guiSession.checkControllerInSession(name))
    {
      String message = GuiTranslate.get("error.controller.already.in.session");
      CJDBCException e = new CJDBCException(message);
      appendDebugText(message, e);
    }
    else
    {
      actionLoadController(name);
      paintControllerPane();
    }
  }

  private void actionLoadController(String name)
  {
    guiSession.addControllerToList(name);
    ControllerObject co = new ControllerObject(name);
    co.setActionCommand(GuiCommands.COMMAND_SELECT_CONTROLLER);
    co.addActionListener(guiActionListener);
    co.addMouseListener(new ControllerPopUpMenu(this, co));
    ControllerMBean controllerMBean = actionGETControllerBean(name);
    if (controllerMBean == null)
    {
      appendDebugText("Cannot load controller:" + name);
      return;
    }
    DropTarget target = new DropTarget(co, DnDConstants.ACTION_MOVE,
        configurationFileTransferListener);
    co.setDropTarget(target);
    appendDebugText("Loading controller:" + controllerMBean.getJmxName());
    if (currentJmxClient.isValidConnection())
    {
      co.setState(GuiConstants.CONTROLLER_STATE_UP);
    }
    else
    {
      co.setState(GuiConstants.CONTROLLER_STATE_DOWN);
    }
    actionAddObjectToGridLayout(controllerListPanel, co);
    controllerList.put(name, co);
  }

  public void publicActionSelectNewController(String connectUrl)
  {
    Enumeration enume = controllerList.keys();
    String key = "";
    ControllerObject controller;
    while (enume.hasMoreElements())
    {
      key = (String) enume.nextElement();
      controller = (ControllerObject) controllerList.get(key);
      if (key.equalsIgnoreCase(connectUrl))
      {
        controller.setBorder(GuiConstants.TITLED_BORDER);
        controller.setBorderPainted(true);
      }
      else
        controller.setBorderPainted(false);
    }
    actionGETControllerBean(connectUrl);
    selectedController = connectUrl;
    actionLoadDatabaseList(connectUrl);
    publicActionLoadXmlController(connectUrl);

    if (selectedDatabase != null)
      publicActionLoadAuthenticatedDatabase();

  }

  public void publicActionLoadDumpList(String connectUrl)
  {
    ControllerMBean controllerMBean = actionGETControllerBean(connectUrl);
    try
    {
      File[] dumps = controllerMBean.listAvailableDumpFiles();
      appendDebugText("Loaded dumps for controller:" + connectUrl);
      JPanel dumpPane = (JPanel) backendsState
          .get(GuiConstants.BACKEND_STATE_RESTORE);
      dumpPane.removeAll();
      for (int i = 0; i < dumps.length; i++)
      {
        appendDebugText("Adding dump:" + dumps[i]);
        DumpFileObject dfo = new DumpFileObject(dumps[i])
        {
          public JToolTip createToolTip()
          {
            return new JMultiLineToolTip();
          }
        };
        dfo.addMouseListener(new DumpPopUpMenu(this, connectUrl, dfo));
        DropTarget target = new DropTarget(dfo, DnDConstants.ACTION_MOVE,
            backendTransferListener);
        dfo.setDropTarget(target);
        dumpPane.add(dfo);
      }
      paintBackendPane();
    }
    catch (Exception e)
    {
      e.printStackTrace();
      appendDebugText("Failed to load dumps for controller:" + connectUrl
          + " because of:" + e.getMessage());
    }
  }

  public void publicActionLoadXmlController(String connectUrl)
  {
    try
    {
      ControllerMBean controllerMBean = actionGETControllerBean(connectUrl);
      xmlTextPane.setText(controllerMBean.viewInfo());
      appendDebugText("Loaded xml configuration for controller:" + connectUrl);
    }
    catch (Exception e)
    {
      appendDebugText("Failed to get xml configuration for controller:"
          + connectUrl);
    }
  }

  public void publicActionSelectNewDatabase(String value)
  {
    selectedDatabase = value;
    try
    {
      VirtualDatabaseMBean databaseClient = actionGETDatabaseBean(value);
      if (databaseClient != null)
      {
        databaseClient.viewControllerList();
        publicActionLoadAuthenticatedDatabase();
      }
      Enumeration enume = databaseList.keys();
      String key = "";
      DatabaseObject database;
      while (enume.hasMoreElements())
      {
        key = (String) enume.nextElement();
        database = (DatabaseObject) databaseList.get(key);
        if (key.equalsIgnoreCase(value))
        {
          database.setBorder(GuiConstants.TITLED_BORDER);
          database.setBorderPainted(true);
        }
        else
          database.setBorderPainted(false);
      }
    }
    catch (Exception e)
    {
      appendDebugText("Failed to get access to database:" + value, e);
    }
  }

  public void publicActionLoadXmlDatabase(String databaseName)
  {
    try
    {
      DatabaseObject dob = (DatabaseObject) databaseList.get(databaseName);
      ControllerMBean controllerMBean = actionGETControllerBean(dob
          .getControllerName());
      xmlTextPane.setText(controllerMBean.viewDatabaseXml(databaseName));
      appendDebugText("Loaded xml configuration for database:" + databaseName);
      centerPane.setSelectedComponent(xmlScroll);
    }
    catch (Exception e)
    {
      appendDebugText("Failed to get xml configuration for database:"
          + databaseName, e);
    }
  }

  public void publicActionSelectNewConfigurationFile(String file)
  {
    try
    {
      xmlTextPane.setText(actionLoadXmlText(new File(file)));
      appendDebugText("Loaded xml configuration for file:" + file);
      centerPane.setSelectedComponent(xmlScroll);
    }
    catch (Exception e)
    {
      appendDebugText("Failed to load xml for file:" + file);
    }
  }

  public void publicActionShutdownDatabase(DatabaseObject dob, int shutdownLevel)
  {
    try
    {
      ControllerMBean controllerMBean = actionGETControllerBean(dob
          .getControllerName());
      String databaseName = dob.getName();
      controllerMBean.shutdownDatabase(databaseName, shutdownLevel);
      controllerListPanel.remove(dob);
      guiSession.getDatabaseItems().remove(databaseName);
      actionUnloadBackends(dob.getControllerName());
      actionLoadDatabaseList(dob.getControllerName());
    }
    catch (Exception e)
    {
      appendDebugText("Failed to shutdown database", e);
    }
  }

  public void publicActionExecuteBackendDrop(JButton target, String backendName)
  {

    String actionName = target.getActionCommand();
    if (actionName.equals(GuiConstants.BACKEND_STATE_RESTORE))
      publicActionRestoreBackend(backendName, target.getText());
    else
      publicActionExecuteBackendDrop(actionName, backendName);
  }

  private String actionDisplaySelectCheckpointFrame(String database)
  {
    VirtualDatabaseMBean databaseMBean = actionGETDatabaseBean(database);
    if (selectCheckpointFrame == null)
    {
      ArrayList list = databaseMBean.viewCheckpointNames();
      list.add(GuiConstants.BACKEND_NO_CHECKPOINT);
      String[] entries = (String[]) list.toArray(new String[list.size()]);
      selectCheckpointFrame = new GuiSelectCheckpoint(this, entries,
          guiActionListener);
      selectCheckpointFrame.show();
    }

    JTextField field = selectCheckpointFrame.getValueField();
    selectCheckpointFrame = null;
    if(field==null)
      return null;
    String checkpoint = field.getText();
    return checkpoint;
  }

  public void publicActionExecuteBackendDrop(String actionName,
      String backendName)
  {
    appendDebugText("Got drop backend action:" + actionName + " from:"
        + backendName);
    BackendObject bob = (BackendObject) backendList.get(backendName);
    String database = bob.getDatabase();
    VirtualDatabaseMBean databaseMBean = actionGETDatabaseBean(bob
        .getDatabase());

    if (actionName.equals(GuiConstants.BACKEND_STATE_ENABLED))
    {
      try
      {
        String checkpoint = actionDisplaySelectCheckpointFrame(database);
        if(checkpoint == null)
        {
          appendDebugText("Cancelling enable backend...");
          return;
        }
        appendDebugText("Using checkpoint:" + checkpoint
            + " to enable backend:" + backendName);
        if (checkpoint.equals(GuiConstants.BACKEND_NO_CHECKPOINT))
          databaseMBean.enableBackend(backendName);
        else
          databaseMBean.enableBackendFromCheckpoint(backendName, checkpoint);
        actionSetBackendState(backendName);
      }
      catch (Exception e)
      {
        appendDebugText("Failed to enable backend", e);
      }
    }
    else if (actionName.equals(GuiConstants.BACKEND_STATE_DISABLED))
    {
      try
      {
        String checkpoint = actionDisplaySelectCheckpointFrame(database);
        if(checkpoint == null)
        {
          appendDebugText("Cancelling disable backend...");
          return;
        }
        appendDebugText("Using checkpoint:" + checkpoint
            + " to disable backend:" + backendName);
        if (checkpoint.equals(GuiConstants.BACKEND_NO_CHECKPOINT))
          databaseMBean.disableBackend(backendName);
        else
          databaseMBean.disableBackendForCheckpoint(backendName, checkpoint);
        actionSetBackendState(backendName);
      }
      catch (Exception e)
      {
        appendDebugText("Failed to disable backend", e);
      }
    }
    else if (actionName.equals(GuiConstants.BACKEND_STATE_NEW))
    {
      appendDebugText("Creating new backend from backend:" + bob.getName());
      publicActionNewBackendPrompt(bob);
    }
    else if (actionName.equals(GuiConstants.BACKEND_STATE_BACKUP))
    {
      publicActionBackupBackendPrompt(bob);
    }
  }

  public void publicActionNewBackendPrompt(BackendObject bob)
  {
    if (newBackendFrame == null)
      newBackendFrame = new NewBackendFrame(bob, guiActionListener);
    else
      newBackendFrame.setBob(bob);
    newBackendFrame.setVisible(true);
  }

  public void publicActionRestoreBackend(String backendName, String dumpName)
  {
    appendDebugText("Restoring backend:" + backendName + " with dump name:"
        + dumpName);
    BackendObject bob = (BackendObject) backendList.get(backendName);
    VirtualDatabaseMBean database = actionGETDatabaseBean(bob.getDatabase());
    new Thread(new RestoreBackendTask(this, database, bob, dumpName)).start();
  }

  public void publicActionBackupBackendPrompt(BackendObject bob)
  {
    String checkpoint = actionDisplaySelectCheckpointFrame(bob.getDatabase());
    VirtualDatabaseMBean database = actionGETDatabaseBean(bob.getDatabase());
    new Thread(new BackupBackendTask(this, database, bob, checkpoint)).start();
  }

  public void publicActionRefreshCursorShape()
  {
    appendDebugText("Refresh cursor for main frame");
    Cursor cursor = Cursor.getPredefinedCursor(Cursor.HAND_CURSOR);
    setCursor(cursor);
    backendPanel.setCursor(cursor);
    validate();
    repaint();
  }

  public void publicActionExecuteControllerDrop(String filePath,
      String controllerName)
  {
    File file = new File(filePath);
    try
    {
      ControllerMBean controllerMBean = actionGETControllerBean(controllerName);
      controllerMBean.addVirtualDatabases(actionLoadXmlText(file));
      appendDebugText("Execute public action on controller drop for:"
          + filePath + " and:" + controllerName);
      actionLoadDatabaseList(controllerName);
    }
    catch (Exception e)
    {
      appendDebugText("Failed to load configuration file :" + file.getName(), e);
    }
  }

  public void publicActionDatabaseDisableAll(String databaseName)
  {
    try
    {
      actionGETDatabaseBean(databaseName).disableAllBackend();
      publicActionLoadBackendsList(databaseName);
      centerPane.setSelectedComponent(backendPanel);
      appendDebugText("Disable All backends for :" + databaseName
          + " was a success");
    }
    catch (Exception e)
    {
      appendDebugText("Disable All backends for :" + databaseName + " failed.",
          e);
    }
  }

  public void publicActionGetControllerInfo(String controllerName)
  {
    try
    {
      ControllerMBean controllerMBean = actionGETControllerBean(controllerName);
      infoTextPane.setText(controllerMBean.viewInfo());
      centerPane.setSelectedComponent(infoScroll);
    }
    catch (Exception e)
    {
      appendDebugText("Failed to get info for controller:" + controllerName, e);
    }
  }

  public void publicActionShutdownController(String controllerName)
  {
    try
    {
      ControllerMBean controllerMBean = actionGETControllerBean(controllerName);
      controllerMBean.shutdown(2);
      publicActionLoadControllerList();
    }
    catch (Exception e)
    {
      appendDebugText("Failed to shutdown the controller:" + controllerName, e);
    }
  }

  public void publicActionControllerReport(String controllerName)
  {
    try
    {
      ControllerMBean controllerMBean = actionGETControllerBean(controllerName);
      infoTextPane.setText(controllerMBean.generateReport());
      centerPane.setSelectedComponent(infoScroll);
    }
    catch (Exception e)
    {
      appendDebugText("Failed to get info for controller:" + controllerName, e);
    }
  }

  public void publicActionDeleteDump(String controllerName, DumpFileObject dump)
  {
    ControllerMBean controller = actionGETControllerBean(controllerName);
    try
    {
      controller.removeDumpFile(dump.getDumpFile());
      appendDebugText("Removed dump file:" + dump.getDumpFile().getName()
          + " from controller:" + controllerName);
      publicActionLoadDumpList(controllerName);
    }
    catch (Exception e)
    {
      appendDebugText(
          "Failed to removed dump file:" + dump.getDumpFile().getName()
              + " from controller:" + controllerName, e);
    }
  }

  public void publicActionExecuteBackendDrop(JPanel panel, String backendName)
  {
    publicActionExecuteBackendDrop(panel.getName(), backendName);
  }

  public void publicActionControllerLogConfiguration(String controllerName)
  {
    try
    {
      ControllerMBean controllerMBean = actionGETControllerBean(controllerName);
      logConfigTextPane.setText(controllerMBean.viewLogConfigurationFile());
      centerPane.setSelectedComponent(logConfigScroll);
      logConfigTextPane.addMouseListener(new LogEditPopUpMenu(this,
          controllerName, logConfigTextPane));
    }
    catch (Exception e)
    {
      appendDebugText("Failed to get log4j configuration for controller:"
          + controllerName, e);
    }
  }

  public void publicActionUpdateControllerLogConfiguration(
      String controllerName, String newContent)
  {
    try
    {
      appendDebugText("Updating log4j configuration for controller:"
          + controllerName);
      ControllerMBean controllerMBean = actionGETControllerBean(controllerName);
      controllerMBean.updateLogConfigurationFile(newContent);
      actionStartControllerLoggingThread(controllerName);
    }
    catch (Exception e)
    {
      appendDebugText("Failed to update log4j configuration for controller:"
          + controllerName, e);
    }
  }

  public void publicActionSetLogConfigurationDebug(String controllerName,
      String logConfiguration)
  {
    try
    {
      String newContent = actionReplaceInConfiguration(logConfiguration,
          "INFO", "DEBUG");
      publicActionUpdateControllerLogConfiguration(controllerName, newContent);
    }
    catch (Exception e)
    {
      appendDebugText("Setting log configation to debug failed for controller:"
          + controllerName, e);
    }
  }

  private String actionReplaceInConfiguration(String logConfiguration,
      String oldMode, String newMode) throws IOException
  {
    BufferedReader reader = new BufferedReader(new StringReader(
        logConfiguration));
    StringBuffer buffer = new StringBuffer();
    String line;
    int index = 0;
    while ((line = reader.readLine()) != null)
    {
      while ((index = line.indexOf(oldMode, index)) != -1)
        line = line.substring(0, index) + newMode
            + line.substring(index + oldMode.length());
      buffer.append(line + System.getProperty("line.separator"));
    }
    logConfigTextPane.setText(buffer.toString());
    return buffer.toString();
  }

  public void publicActionSetLogConfigurationInfo(String controllerName,
      String logConfiguration)
  {
    try
    {
      String newContent = actionReplaceInConfiguration(logConfiguration,
          "DEBUG", "INFO");
      publicActionUpdateControllerLogConfiguration(controllerName, newContent);
    }
    catch (Exception e)
    {
      appendDebugText("Setting log configation to debug failed for controller:"
          + controllerName, e);
    }

  }

  public Hashtable getBackendList()
  {
    return backendList;
  }

  public void publicActioncleanLoggingPane()
  {
    loggingTextPane.setText("");
    loggingTextPane.validate();
    loggingTextPane.repaint();
  }

  public void publicActionRemoveConfigurationFile(ConfigurationFileObject cfo)
  {
    Container container = cfo.getParent();
    container.remove(cfo);
    System.out.println(guiSession.getConfigurationFiles().remove(
        new File(cfo.getFilePath())));
    container.validate();
    container.repaint();
  }

  public void publicActionControllerRemove(String controllerName)
  {
    ControllerObject co = (ControllerObject) controllerList
        .remove(controllerName);
    if (co != null)
    {
      controllerListPanel.remove(co);
      controllerListPanel.validate();
      controllerListPanel.repaint();
    }
    guiSession.getControllerItems().remove(controllerName);
  }

  public void publicActionControllerMonitor(String controllerName)
  {
    appendDebugText("Creating monitoring console for controller:"
        + controllerName);
    try
    {
      new MonitoringConsole(controllerName);
    }
    catch (Exception e)
    {
      appendDebugText("Loading of monitoring console failed for controller:"
          + controllerName, e);
    }
  }

  public void publicActionCreateBackendExecute()
  {
    newBackendFrame.setVisible(false);
    BackendObject bob = newBackendFrame.getBob();
    VirtualDatabaseMBean database = actionGETDatabaseBean(bob.getDatabase());
    String oldname = bob.getName();
    String newname = newBackendFrame.getNewName().getText();
    String url = newBackendFrame.getNewUrl().getText();
    HashMap map = new HashMap();
    map.put("url", url);
    try
    {
      database.replicateBackend(oldname, newname, map);
    }
    catch (Exception e)
    {
      appendDebugText("Failed to create new backend:" + newname, e);
    }
  }

  public void publicActionViewCache(String databaseName)
  {
    try
    {
      DataCollectorMBean collector = currentJmxClient.getDataCollectorProxy();
      CacheViewer viewer = new CacheViewer(collector
          .retrieveCacheData(databaseName));
      viewer.display();
    }
    catch (Exception e)
    {
      appendDebugText("Failed to collect cache data for database:"
          + databaseName, e);
    }
  }

  public void publicActionViewSQLStats(String databaseName)
  {
    try
    {
      DataCollectorMBean collector = currentJmxClient.getDataCollectorProxy();
      SQLStatViewer viewer = new SQLStatViewer(collector
          .retrieveSQLStats(databaseName));
      viewer.display();
    }
    catch (Exception e)
    {
      appendDebugText(
          "Failed to collect sql data for database:" + databaseName, e);
    }

  }

  public void publicActionViewCacheStats(String databaseName)
  {
    try
    {
      DataCollectorMBean collector = currentJmxClient.getDataCollectorProxy();
      CacheStatsViewer viewer = new CacheStatsViewer(collector
          .retrieveCacheStatsData(databaseName));
      viewer.display();
    }
    catch (Exception e)
    {
      appendDebugText("Failed to collect cache stats for database:"
          + databaseName, e);
    }
  }

  public CjdbcGuiListener getGuiActionListener()
  {
    return guiActionListener;
  }

  public GuiSession getGuiSession()
  {
    return guiSession;
  }

  public Hashtable getJmxClients()
  {
    return jmxClients;
  }

  public void publicActionRemoveBackendFromGui(String backendName)
  {
    BackendObject bo = (BackendObject) backendList.remove(backendName);
    if (bo != null)
    {
      backendIcons.remove(bo);
      JPanel panel = (JPanel) backendsState.get(bo.getState());
      panel.remove(bo);
      paintBackendPane();
    }
  }

  public void publicActionRemoveBackend(BackendObject bo)
  {
    String controllerName = bo.getControllerName();
    String databaseName = bo.getDatabase();
    String backendName = bo.getName();
    RmiJmxClient jmxClient = (RmiJmxClient) jmxClients.get(controllerName);
    String user = guiSession.getAuthenticatedDatabaseLogin(databaseName);
    String password = guiSession.getAuthenticatedDatabasePassword(databaseName);
    try
    {
      VirtualDatabaseMBean mbean = jmxClient.getVirtualDatabaseProxy(
          databaseName, user, password);
      mbean.removeBackend(backendName);
      publicActionRemoveBackendFromGui(backendName);
    }
    catch (Exception e)
    {
      appendDebugText("Cannot remove backend:" + backendName, e);
    }

  }

  public void publicActionExecuteTransfer(String backendName,
      String controllerName)
  {
    BackendObject bo = (BackendObject) backendList.get(backendName);
    String controllerNameOrigin = bo.getControllerName();
    RmiJmxClient jmxClient = (RmiJmxClient) jmxClients
        .get(controllerNameOrigin);
    String databaseName = bo.getDatabase();
    String user = guiSession.getAuthenticatedDatabaseLogin(databaseName);
    String password = guiSession.getAuthenticatedDatabasePassword(databaseName);
    try
    {
      VirtualDatabaseMBean mbean = jmxClient.getVirtualDatabaseProxy(
          databaseName, user, password);
      mbean.transferBackend(backendName, controllerName);
      bo.setControllerName(controllerName);
      //publicActionRemoveBackendFromGui(backendName);
    }
    catch (Exception e)
    {
      appendDebugText("Cannot remove backend:" + backendName, e);
    }
  }

  public void publicActionRemoveBackendFromGui(String backendName,
      String controller)
  {
    BackendObject bo = (BackendObject) backendList.get(backendName);
    if (bo != null)
    {
      String boController = bo.getControllerName();
      if (boController.equals(controller))
        publicActionRemoveBackendFromGui(backendName);
      else
      {
        appendDebugText("Call for removing backend:" + backendName
            + " from controller:" + controller
            + " but backend is on controller:" + boController);
      }
    }

  }

  public void publicActionDisplayShutdownFrame(DatabaseObject database)
  {
    if (selectShutdownFrame == null)
    {
      selectShutdownFrame = new GuiSelectShutdown(this, guiActionListener);
      selectShutdownFrame.show();
    }
    String shutdownLevel = selectShutdownFrame.getValueField().getText();
    int iLevel = Constants.DEFAULT_SHUTDOWN_MODE;
    if (shutdownLevel.equals(GuiCommands.COMMAND_SHUTDOWN_FAST))
      iLevel = Constants.CONTROLLER_SHUTDOWN_FAST;
    else if (shutdownLevel.equals(GuiCommands.COMMAND_SHUTDOWN_IMMEDIATE))
      iLevel = Constants.CONTROLLER_SHUTDOWN_IMMEDIATE;
    else if (shutdownLevel.equals(GuiCommands.COMMAND_SHUTDOWN_SMART))
      iLevel = Constants.CONTROLLER_SHUTDOWN_SMART;
    appendDebugText("shudown level of database:" + database.getName() + " is:"
        + shutdownLevel);
    selectShutdownFrame = null;
    publicActionShutdownDatabase(database, iLevel);
  }

  public void publicActionViewRecoveryLog(String databaseName)
  {
    try
    {
      DataCollectorMBean collector = currentJmxClient.getDataCollectorProxy();
      RecoveryLogViewer viewer = new RecoveryLogViewer(collector
          .retrieveRecoveryLogData(databaseName));
      viewer.display();
    }
    catch (Exception e)
    {
      appendDebugText("Failed to collect cache stats for database:"
          + databaseName, e);
    }
  }
}

---