org.eclipse.linuxtools.lttng2.ui/src/org/eclipse/linuxtools/internal/lttng2/ui/views/control/model/impl/TargetNodeComponent.java

   1 /**********************************************************************
   2  * Copyright (c) 2012, 2013 Ericsson
   3  *
   4  * All rights reserved. This program and the accompanying materials are
   5  * made available under the terms of the Eclipse Public License v1.0 which
   6  * accompanies this distribution, and is available at
   7  * http://www.eclipse.org/legal/epl-v10.html
   8  *
   9  * Contributors:
  10  *   Bernd Hufmann - Initial API and implementation
  11  *   Bernd Hufmann - Updated for support of LTTng Tools 2.1
  12  **********************************************************************/
  13 package org.eclipse.linuxtools.internal.lttng2.ui.views.control.model.impl;
  14
  15 import java.util.List;
  16
  17 import org.eclipse.core.commands.ExecutionException;
  18 import org.eclipse.core.runtime.IProgressMonitor;
  19 import org.eclipse.core.runtime.IStatus;
  20 import org.eclipse.core.runtime.Status;
  21 import org.eclipse.core.runtime.jobs.Job;
  22 import org.eclipse.jface.dialogs.ErrorDialog;
  23 import org.eclipse.linuxtools.internal.lttng2.core.control.model.TargetNodeState;
  24 import org.eclipse.linuxtools.internal.lttng2.ui.Activator;
  25 import org.eclipse.linuxtools.internal.lttng2.ui.views.control.messages.Messages;
  26 import org.eclipse.linuxtools.internal.lttng2.ui.views.control.model.ITraceControlComponent;
  27 import org.eclipse.linuxtools.internal.lttng2.ui.views.control.property.TargetNodePropertySource;
  28 import org.eclipse.linuxtools.internal.lttng2.ui.views.control.remote.ICommandShell;
  29 import org.eclipse.linuxtools.internal.lttng2.ui.views.control.remote.IRemoteSystemProxy;
  30 import org.eclipse.linuxtools.internal.lttng2.ui.views.control.remote.RemoteSystemProxy;
  31 import org.eclipse.linuxtools.internal.lttng2.ui.views.control.service.ILttngControlService;
  32 import org.eclipse.linuxtools.internal.lttng2.ui.views.control.service.LTTngControlServiceFactory;
  33 import org.eclipse.rse.core.RSECorePlugin;
  34 import org.eclipse.rse.core.model.IHost;
  35 import org.eclipse.rse.core.model.IRSECallback;
  36 import org.eclipse.rse.core.model.ISystemRegistry;
  37 import org.eclipse.rse.core.subsystems.CommunicationsEvent;
  38 import org.eclipse.rse.core.subsystems.ICommunicationsListener;
  39 import org.eclipse.swt.graphics.Image;
  40 import org.eclipse.swt.widgets.Display;
  41 import org.eclipse.ui.PlatformUI;
  42 import org.eclipse.ui.views.properties.IPropertySource;
  43
  44 /**
  45  * <p>
  46  * Implementation of the trace node component.
  47  * </p>
  48  *
  49  * @author Bernd Hufmann
  50  */
  51 public class TargetNodeComponent extends TraceControlComponent implements ICommunicationsListener {
  52
  53     // ------------------------------------------------------------------------
  54     // Constants
  55     // ------------------------------------------------------------------------
  56
  57     /**
  58      * Path to icon file for this component (state connected).
  59      */
  60     public static final String TARGET_NODE_CONNECTED_ICON_FILE = "icons/obj16/target_connected.gif"; //$NON-NLS-1$
  61     /**
  62      * Path to icon file for this component (state disconnected).
  63      */
  64     public static final String TARGET_NODE_DISCONNECTED_ICON_FILE = "icons/obj16/target_disconnected.gif"; //$NON-NLS-1$
  65
  66     // ------------------------------------------------------------------------
  67     // Attributes
  68     // ------------------------------------------------------------------------
  69
  70     /**
  71      * The node connection state.
  72      */
  73     private TargetNodeState fState = TargetNodeState.DISCONNECTED;
  74     /**
  75      * The image to be displayed in state disconnected.
  76      */
  77     private Image fDisconnectedImage = null;
  78     /**
  79      * The connection implementation.
  80      */
  81     private IHost fHost = null;
  82     /**
  83      * The remote proxy implementation.
  84      */
  85     private IRemoteSystemProxy fRemoteProxy = null;
  86     /**
  87      * The control service for LTTng specific commands.
  88      */
  89     private ILttngControlService fService = null;
  90     /**
  91      * The command shell for issuing commands.
  92      */
  93     private ICommandShell fShell = null;
  94
  95     // ------------------------------------------------------------------------
  96     // Constructors
  97     // ------------------------------------------------------------------------
  98
  99     /**
 100      * Constructor
 101      * @param name - the name of the component
 102      * @param parent - the parent of the component
 103      * @param host - the host connection implementation
 104      * @param proxy - the remote proxy implementation
 105      */
 106     public TargetNodeComponent(String name, ITraceControlComponent parent, IHost host, IRemoteSystemProxy proxy) {
 107         super(name, parent);
 108         setImage(TARGET_NODE_CONNECTED_ICON_FILE);
 109         fDisconnectedImage = Activator.getDefault().loadIcon(TARGET_NODE_DISCONNECTED_ICON_FILE);
 110         fHost = host;
 111         fRemoteProxy = proxy;
 112         setToolTip(fHost.getHostName());
 113     }
 114
 115     /**
 116      * Constructor (using default proxy)
 117      * @param name - the name of the component
 118      * @param parent - the parent of the component
 119      * @param host - the host connection implementation
 120      */
 121     public TargetNodeComponent(String name, ITraceControlComponent parent, IHost host) {
 122         this(name, parent, host, new RemoteSystemProxy(host));
 123     }
 124
 125     // ------------------------------------------------------------------------
 126     // Accessors
 127     // ------------------------------------------------------------------------
 128
 129     @Override
 130     public Image getImage() {
 131         if (fState == TargetNodeState.CONNECTED) {
 132             return super.getImage();
 133         }
 134         return fDisconnectedImage;
 135     }
 136
 137     @Override
 138     public TargetNodeState getTargetNodeState() {
 139         return fState;
 140     }
 141
 142     @Override
 143     public void setTargetNodeState(TargetNodeState state) {
 144         fState = state;
 145         fireComponentChanged(TargetNodeComponent.this);
 146     }
 147
 148     @Override
 149     public ILttngControlService getControlService() {
 150         return fService;
 151     }
 152
 153     @Override
 154     public void setControlService(ILttngControlService service) {
 155         fService = service;
 156     }
 157
 158     @Override
 159     public Object getAdapter(Class adapter) {
 160         if (adapter == IPropertySource.class) {
 161             return new TargetNodePropertySource(this);
 162         }
 163         return null;
 164     }
 165
 166     /**
 167      * @return remote host name
 168      */
 169     public String getHostName() {
 170         return fHost.getHostName();
 171     }
 172
 173     /**
 174      * @return remote system proxy implementation
 175      */
 176     public IRemoteSystemProxy getRemoteSystemProxy() {
 177         return fRemoteProxy;
 178     }
 179
 180     /**
 181      * @return port of IP connection (shell) to be used
 182      */
 183     public int getPort() {
 184         return fRemoteProxy.getPort();
 185     }
 186
 187     /**
 188      * Sets the port of the IP connections of the shell
 189      * @param port - the IP port to set
 190      */
 191     public void setPort(int port) {
 192         fRemoteProxy.setPort(port);
 193     }
 194
 195     /**
 196      * @return all available sessions.
 197      */
 198     public TraceSessionComponent[] getSessions() {
 199         List<ITraceControlComponent> compenents = getChildren(TraceSessionGroup.class);
 200         if (compenents.size() > 0) {
 201             TraceSessionGroup group = (TraceSessionGroup)compenents.get(0);
 202             List<ITraceControlComponent> sessions = group.getChildren(TraceSessionComponent.class);
 203             return sessions.toArray(new TraceSessionComponent[sessions.size()]);
 204         }
 205         return new TraceSessionComponent[0];
 206     }
 207
 208     /**
 209      * @return node version
 210      */
 211     public String getNodeVersion() {
 212         // Control service is null during connection to node
 213         if (getControlService() != null) {
 214             return getControlService().getVersion();
 215         }
 216         return ""; //$NON-NLS-1$
 217     }
 218
 219     /**
 220      * Returns if node supports filtering of events
 221      * @return <code>true</code> if node supports filtering else <code>false</code>
 222      */
 223     public boolean isEventFilteringSupported() {
 224         return getControlService().isVersionSupported("2.1.0"); //$NON-NLS-1$
 225     }
 226
 227     /**
 228      * Returns if node supports networks streaming or not
 229      * @return <code>true</code> if node supports filtering else <code>false</code>
 230      *
 231      */
 232     public boolean isNetworkStreamingSupported() {
 233         return getControlService().isVersionSupported("2.1.0"); //$NON-NLS-1$
 234     }
 235
 236     /**
 237      * Returns if node supports per UID buffers or not
 238      * @return <code>true</code> if node supports per UID buffers else <code>false</code>
 239      */
 240     public boolean isPerUIDBuffersSupported() {
 241         return getControlService().isVersionSupported("2.2.0"); //$NON-NLS-1$
 242     }
 243
 244     /**
 245      * Returns if node supports trace file rotation or not
 246      * @return <code>true</code> if node supports trace file rotation else <code>false</code>
 247      */
 248     public boolean isTraceFileRotationSupported() {
 249         return getControlService().isVersionSupported("2.2.0"); //$NON-NLS-1$
 250     }
 251
 252     /**
 253      * Returns if node supports periodical flush for metadata or not
 254      * @return <code>true</code> if node supports periodical flush for metadata else <code>false</code>
 255      */
 256     public boolean isPeriodicalMetadataFlushSupported() {
 257         return getControlService().isVersionSupported("2.2.0"); //$NON-NLS-1$
 258     }
 259
 260     // ------------------------------------------------------------------------
 261     // Operations
 262     // ------------------------------------------------------------------------
 263
 264    @Override
 265    public void communicationsStateChange(CommunicationsEvent e) {
 266        if (e.getState() == CommunicationsEvent.AFTER_DISCONNECT ||
 267                e.getState() == CommunicationsEvent.CONNECTION_ERROR) {
 268            handleDisconnected();
 269        } if ((e.getState() == CommunicationsEvent.AFTER_CONNECT) && (fState != TargetNodeState.CONNECTING)) {
 270            handleConnected();
 271        }
 272    }
 273
 274    @Override
 275    public boolean isPassiveCommunicationsListener() {
 276        return true;
 277    }
 278
 279    @Override
 280    public void dispose() {
 281        fRemoteProxy.removeCommunicationListener(this);
 282    }
 283
 284    /**
 285     * Method to connect this node component to the remote target node.
 286     */
 287    public void connect() {
 288        if (fState == TargetNodeState.DISCONNECTED) {
 289            try {
 290                setTargetNodeState(TargetNodeState.CONNECTING);
 291                fRemoteProxy.connect(new IRSECallback() {
 292                    @Override
 293                    public void done(IStatus status, Object result) {
 294                        // Note: result might be null!
 295                        if(status.isOK()) {
 296                            handleConnected();
 297                        } else {
 298                            handleDisconnected();
 299                        }
 300                    }
 301                });
 302            } catch (Exception e) {
 303                setTargetNodeState(TargetNodeState.DISCONNECTED);
 304                Activator.getDefault().logError(Messages.TraceControl_ConnectionFailure + " (" + getName() + "). \n", e); //$NON-NLS-1$ //$NON-NLS-2$
 305            }
 306        }
 307     }
 308
 309    /**
 310     * Method to disconnect this node component to the remote target node.
 311     */
 312     public void disconnect() {
 313         if (fState == TargetNodeState.CONNECTED) {
 314             try {
 315                 setTargetNodeState(TargetNodeState.DISCONNECTING);
 316                 fRemoteProxy.disconnect();
 317             } catch (Exception e) {
 318                 Activator.getDefault().logError(Messages.TraceControl_DisconnectionFailure + " (" + getName() + "). \n", e); //$NON-NLS-1$ //$NON-NLS-2$
 319             } finally {
 320                 handleDisconnected();
 321             }
 322         }
 323     }
 324
 325     /**
 326      * Retrieves the trace configuration from the target node and populates the
 327      * information in the tree model. The execution is done in a own job.
 328      */
 329     public void getConfigurationFromNode() {
 330         Job job = new Job(Messages.TraceControl_RetrieveNodeConfigurationJob) {
 331             @Override
 332             protected IStatus run(IProgressMonitor monitor) {
 333
 334                 try {
 335                     // Get provider information from node
 336                     TraceProviderGroup providerGroup = new TraceProviderGroup(Messages.TraceControl_ProviderDisplayName, TargetNodeComponent.this);
 337                     addChild(providerGroup);
 338                     providerGroup.getProviderFromNode(monitor);
 339
 340                     // Get session information from node
 341                     TraceSessionGroup sessionGroup = new TraceSessionGroup(Messages.TraceControl_AllSessionsDisplayName, TargetNodeComponent.this);
 342                     addChild(sessionGroup);
 343                     sessionGroup.getSessionsFromNode(monitor);
 344                 } catch (ExecutionException e) {
 345                     removeAllChildren();
 346                     return new Status(IStatus.ERROR, Activator.PLUGIN_ID, Messages.TraceControl_RetrieveNodeConfigurationFailure, e);
 347                 }
 348
 349                 return Status.OK_STATUS;
 350             }
 351         };
 352         job.setUser(true);
 353         job.schedule();
 354     }
 355
 356     /**
 357      * Refresh the node configuration
 358      */
 359     public void refresh() {
 360         removeAllChildren();
 361         getConfigurationFromNode();
 362     }
 363
 364     /**
 365      * Deregisters host from registry.
 366      */
 367     public void deregister() {
 368         ISystemRegistry registry = RSECorePlugin.getTheSystemRegistry();
 369         registry.deleteHost(fHost);
 370     }
 371
 372     // ------------------------------------------------------------------------
 373     // Helper function
 374     // ------------------------------------------------------------------------
 375
 376     /**
 377      * @return returns the control service for LTTng specific commands.
 378      * @throws ExecutionException
 379      */
 380     private ILttngControlService createControlService() throws ExecutionException {
 381         if (fShell == null) {
 382             fShell = fRemoteProxy.createCommandShell();
 383             fRemoteProxy.addCommunicationListener(this);
 384         }
 385         fService = LTTngControlServiceFactory.getInstance().getLttngControlService(fShell);
 386         return fService;
 387     }
 388
 389     /**
 390      * Handles the connected event.
 391      */
 392     private void handleConnected() {
 393         setTargetNodeState(TargetNodeState.CONNECTED);
 394         try {
 395             createControlService();
 396             getConfigurationFromNode();
 397         } catch (final ExecutionException e) {
 398             // Disconnect only if no control service, otherwise stay connected.
 399             if (getControlService() == null) {
 400                 disconnect();
 401             }
 402
 403             // Notify user
 404             Display.getDefault().asyncExec(new Runnable() {
 405                 @Override
 406                 public void run() {
 407                     ErrorDialog er = new ErrorDialog(PlatformUI.getWorkbench().getActiveWorkbenchWindow().getShell(),
 408                             Messages.TraceControl_ErrorTitle, Messages.TraceControl_RetrieveNodeConfigurationFailure,
 409                             new Status(IStatus.ERROR, Activator.PLUGIN_ID, e.getMessage(), e),
 410                             IStatus.ERROR);
 411                     er.open();
 412                 }
 413             });
 414             Activator.getDefault().logError(Messages.TraceControl_RetrieveNodeConfigurationFailure + " (" + getName() + "). \n", e); //$NON-NLS-1$ //$NON-NLS-2$
 415         }
 416     }
 417
 418     /**
 419      * Handles the disconnected event.
 420      */
 421     private void handleDisconnected() {
 422         removeAllChildren();
 423         setTargetNodeState(TargetNodeState.DISCONNECTED);
 424         fShell = null;
 425         fService = null;
 426     }
 427 }