org.eclipse.linuxtools.lttng.ui/src/org/eclipse/linuxtools/internal/lttng/ui/tracecontrol/subsystems/TraceSubSystem.java

   1 /*******************************************************************************
   2  * Copyright (c) 2011 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  *   Polytechnique Montréal - Initial API and implementation
  11  *   Bernd Hufmann - Productification, enhancements and fixes
  12  *
  13  *******************************************************************************/
  14 package org.eclipse.linuxtools.internal.lttng.ui.tracecontrol.subsystems;
  15
  16 import java.io.File;
  17 import java.util.ArrayList;
  18 import java.util.Arrays;
  19 import java.util.Vector;
  20 import java.util.concurrent.TimeUnit;
  21
  22 import org.eclipse.core.runtime.IProgressMonitor;
  23 import org.eclipse.jface.dialogs.MessageDialog;
  24 import org.eclipse.linuxtools.internal.lttng.core.LttngConstants;
  25 import org.eclipse.linuxtools.internal.lttng.core.tracecontrol.model.ProviderResource;
  26 import org.eclipse.linuxtools.internal.lttng.core.tracecontrol.model.TargetResource;
  27 import org.eclipse.linuxtools.internal.lttng.core.tracecontrol.model.TraceResource;
  28 import org.eclipse.linuxtools.internal.lttng.core.tracecontrol.model.TraceResource.TraceState;
  29 import org.eclipse.linuxtools.internal.lttng.core.tracecontrol.model.config.TraceConfig;
  30 import org.eclipse.linuxtools.internal.lttng.core.tracecontrol.service.ILttControllerService;
  31 import org.eclipse.linuxtools.internal.lttng.core.tracecontrol.service.LttControllerServiceProxy;
  32 import org.eclipse.linuxtools.internal.lttng.core.tracecontrol.utility.LiveTraceManager;
  33 import org.eclipse.linuxtools.internal.lttng.ui.Activator;
  34 import org.eclipse.linuxtools.internal.lttng.ui.tracecontrol.Messages;
  35 import org.eclipse.linuxtools.internal.lttng.ui.tracecontrol.TraceControlConstants;
  36 import org.eclipse.linuxtools.internal.lttng.ui.tracecontrol.actions.ImportToProject;
  37 import org.eclipse.linuxtools.internal.lttng.ui.tracecontrol.actions.PauseTrace;
  38 import org.eclipse.linuxtools.internal.lttng.ui.tracecontrol.connectorservice.TraceConnectorService;
  39 import org.eclipse.rse.core.events.ISystemResourceChangeEvents;
  40 import org.eclipse.rse.core.events.SystemResourceChangeEvent;
  41 import org.eclipse.rse.core.filters.ISystemFilter;
  42 import org.eclipse.rse.core.filters.ISystemFilterPoolReference;
  43 import org.eclipse.rse.core.model.IHost;
  44 import org.eclipse.rse.core.model.ISystemMessageObject;
  45 import org.eclipse.rse.core.model.ISystemRegistry;
  46 import org.eclipse.rse.core.model.SystemMessageObject;
  47 import org.eclipse.rse.core.model.SystemStartHere;
  48 import org.eclipse.rse.core.subsystems.CommunicationsEvent;
  49 import org.eclipse.rse.core.subsystems.ICommunicationsListener;
  50 import org.eclipse.rse.core.subsystems.IConnectorService;
  51 import org.eclipse.rse.core.subsystems.SubSystem;
  52 import org.eclipse.rse.services.clientserver.NamePatternMatcher;
  53 import org.eclipse.rse.services.clientserver.messages.SystemMessageException;
  54 import org.eclipse.rse.ui.SystemBasePlugin;
  55 import org.eclipse.swt.widgets.Display;
  56 import org.eclipse.tcf.protocol.IToken;
  57 import org.eclipse.tcf.util.TCFTask;
  58
  59 /**
  60  * <b><u>TraceSubSystem</u></b>
  61  * <p>
  62  * Implementation of the trace subsystem. Provides methods to initialize connections
  63  * to the remote system, connection handling, filtering and retrival of remote
  64  * system configuration.
  65  * </p>
  66  */
  67 public class TraceSubSystem extends SubSystem implements ICommunicationsListener {
  68
  69     // ------------------------------------------------------------------------
  70     // Attributes
  71     // ------------------------------------------------------------------------
  72
  73     private ProviderResource[] fProviders; // master list of Providers
  74
  75     // ------------------------------------------------------------------------
  76     // Constructors
  77     // ------------------------------------------------------------------------
  78     /**
  79      * @param host
  80      * @param connectorService
  81      */
  82     public TraceSubSystem(IHost host, IConnectorService connectorService) {
  83         super(host, connectorService);
  84     }
  85
  86     // ------------------------------------------------------------------------
  87     // Operations
  88     // ------------------------------------------------------------------------
  89
  90     /*
  91      * (non-Javadoc)
  92      * @see org.eclipse.rse.core.subsystems.SubSystem#initializeSubSystem(org.eclipse.core.runtime.IProgressMonitor)
  93      */
  94     @Override
  95     public void initializeSubSystem(IProgressMonitor monitor) {
  96         getConnectorService().addCommunicationsListener(this);
  97     }
  98
  99     /*
 100      * (non-Javadoc)
 101      * @see org.eclipse.rse.core.subsystems.SubSystem#uninitializeSubSystem(org.eclipse.core.runtime.IProgressMonitor)
 102      */
 103     @Override
 104     public void uninitializeSubSystem(IProgressMonitor monitor) {
 105     }
 106
 107     /*
 108      * (non-Javadoc)
 109      * @see org.eclipse.rse.core.subsystems.SubSystem#getObjectWithAbsoluteName(java.lang.String)
 110      *
 111      * For drag and drop, and clipboard support of remote objects.
 112      *
 113      * Return the remote object within the subsystem that corresponds to the specified unique ID. Because each subsystem maintains it's own objects, it's the responsability of the subsystem to determine how an ID (or key) for a given object maps to
 114      * the real object. By default this returns null.
 115      */
 116     @Override
 117     public Object getObjectWithAbsoluteName(String key) {
 118         return null;
 119     }
 120
 121     /*
 122      * (non-Javadoc)
 123      * @see org.eclipse.rse.core.subsystems.SubSystem#internalResolveFilterString(java.lang.String, org.eclipse.core.runtime.IProgressMonitor)
 124      */
 125     @Override
 126     protected Object[] internalResolveFilterString(String filterString, IProgressMonitor monitor) throws java.lang.reflect.InvocationTargetException, java.lang.InterruptedException {
 127
 128         ProviderResource[] allProviders;
 129
 130         try {
 131              allProviders = getAllProviders();
 132         } catch (SystemMessageException e) {
 133             SystemBasePlugin.logError("TraceSubSystem", e); //$NON-NLS-1$
 134             Object[] children = new SystemMessageObject[1];
 135             children[0] = new SystemMessageObject(e.getSystemMessage(), ISystemMessageObject.MSGTYPE_ERROR, null);
 136             return children;
 137         }
 138
 139         // Now, subset master list, based on filter string...
 140         NamePatternMatcher subsetter = new NamePatternMatcher(filterString);
 141         Vector<ProviderResource> v = new Vector<ProviderResource>();
 142         for (int idx = 0; idx < allProviders.length; idx++) {
 143             if (subsetter.matches(allProviders[idx].getName())) {
 144                 v.addElement(allProviders[idx]);
 145             }
 146         }
 147         return allProviders;
 148     }
 149     /*
 150      * (non-Javadoc)
 151      * @see org.eclipse.rse.core.subsystems.SubSystem#internalResolveFilterString(java.lang.Object, java.lang.String, org.eclipse.core.runtime.IProgressMonitor)
 152      */
 153     @Override
 154     protected Object[] internalResolveFilterString(Object parent, String filterString, IProgressMonitor monitor) throws java.lang.reflect.InvocationTargetException, java.lang.InterruptedException {
 155         return null;
 156     }
 157
 158     /* (non-Javadoc)
 159      * @see org.eclipse.rse.core.subsystems.SubSystem#filterEventFilterCreated(java.lang.Object, org.eclipse.rse.core.filters.ISystemFilter)
 160      */
 161     @Override
 162     public void filterEventFilterCreated(Object selectedObject, ISystemFilter newFilter) {
 163         super.filterEventFilterCreated(selectedObject, newFilter);
 164         ISystemRegistry registry = SystemStartHere.getSystemRegistry();
 165         registry.fireEvent(new SystemResourceChangeEvent(this, ISystemResourceChangeEvents.EVENT_REFRESH, null));
 166     }
 167
 168     /* (non-Javadoc)
 169      * @see org.eclipse.rse.core.subsystems.SubSystem#filterEventFilterPoolReferenceCreated(org.eclipse.rse.core.filters.ISystemFilterPoolReference)
 170      */
 171     @Override
 172     public void filterEventFilterPoolReferenceCreated(ISystemFilterPoolReference newPoolRef) {
 173         super.filterEventFilterPoolReferenceCreated(newPoolRef);
 174         if (getSystemFilterPoolReferenceManager().getSystemFilterPoolReferenceCount() == 1) {
 175             ISystemRegistry registry = SystemStartHere.getSystemRegistry();
 176             registry.fireEvent(new SystemResourceChangeEvent(this, ISystemResourceChangeEvents.EVENT_REFRESH, null));
 177         }
 178     }
 179
 180     /**
 181      * Retrieves all provider resources from the remote system and updates local references.
 182      *
 183      * @return provider resources
 184      * @throws SystemMessageException
 185      * @throws InterruptedException
 186      */
 187     public ProviderResource[] getAllProviders() throws SystemMessageException, InterruptedException {
 188         ProviderResource[] providers = createProviders();
 189         if (fProviders == null) {
 190             fProviders = providers;
 191         }
 192         else {
 193             for (int i = 0; i < fProviders.length; i++) {
 194                 for (int j = 0; j < providers.length; j++) {
 195                     if(fProviders[i].getName().equals(providers[j].getName())) {
 196                         // Check if all targets already exist
 197                         fProviders[i].refreshTargets(providers[j].getTargets());
 198                     }
 199                 }
 200             }
 201         }
 202         return (fProviders != null) ? Arrays.copyOf(fProviders, fProviders.length) : null;
 203     }
 204
 205     /**
 206      * Get the list of all targets.
 207      *
 208      * @return targets The list of targets.
 209      * @throws SystemMessageException
 210      */
 211     public TargetResource[] getAllTargets() throws SystemMessageException {
 212         ArrayList<TargetResource> targets = new ArrayList<TargetResource>();
 213         if (fProviders != null) {
 214             for (int i = 0; i < fProviders.length; i++) {
 215                 targets.addAll(Arrays.asList(fProviders[i].getTargets()));
 216             }
 217         }
 218         return targets.toArray(new TargetResource[0]);
 219     }
 220
 221     /**
 222      * Get the list of all traces.
 223      *
 224      * @return traces The list of traces.
 225      * @throws SystemMessageException
 226      */
 227     public TraceResource[] getAllTraces() throws SystemMessageException {
 228         ArrayList<TraceResource> traces = new ArrayList<TraceResource>();
 229         if (fProviders != null) {
 230             for (int i = 0; i < fProviders.length; i++) {
 231                 ProviderResource provider = fProviders[i];
 232                 int numTargets = provider.getTargets().length;
 233                 for (int j = 0; j < numTargets; j++) {
 234                         TargetResource target = provider.getTargets()[j];
 235                         if (provider.getName().equals(LttngConstants.Lttng_Provider_Kernel)) {
 236                                 traces.addAll(Arrays.asList(target.getTraces()));
 237                         }
 238                 }
 239             }
 240         }
 241         return traces.toArray(new TraceResource[0]);
 242     }
 243
 244     /**
 245      * Get the list of all traces for given provider and target.
 246      *
 247      * @param provider
 248      * @param target
 249      * @returns trace resources
 250      */
 251     public TraceResource[] getAllTraces(String providerName, String targetName) throws SystemMessageException {
 252         ArrayList<TraceResource> traces = new ArrayList<TraceResource>();
 253         ProviderResource selectedProvider = null;
 254         if (fProviders != null) {
 255             for (int i = 0; i < fProviders.length; i++) {
 256                 ProviderResource provider = fProviders[i];
 257                 if (provider.getName().equals(providerName)) {
 258                     selectedProvider = fProviders[i];
 259                     break;
 260                 }
 261             }
 262
 263             if (selectedProvider != null) {
 264                 int numTargets = selectedProvider.getTargets().length;
 265                 for (int j = 0; j < numTargets; j++) {
 266                     TargetResource target = selectedProvider.getTargets()[j];
 267                     if (target.getName().equals(targetName)) {
 268                         traces.addAll(Arrays.asList(target.getTraces()));
 269                         break;
 270                     }
 271                 }
 272             }
 273         }
 274         return traces.toArray(new TraceResource[0]);
 275     }
 276
 277     /**
 278      * Finds a trace resource within a given provider and target for a given trace name
 279      *
 280      * @param targetName - target name to be searched
 281      * @param traceName - trace name to be searched
 282      * @return trace resource or null (if not found)
 283      */
 284     public TraceResource findTrace(String providerName, String targetName, String traceName) {
 285         TraceResource trace = null;
 286         TraceResource[] traces;
 287         try {
 288             traces = getAllTraces(providerName, targetName);
 289             for (int i = 0; i < traces.length; i++) {
 290                 if (traces[i].getName().equals(traceName)) {
 291                     trace = traces[i];
 292                     break;
 293                 }
 294             }
 295         } catch (SystemMessageException e) {
 296             SystemBasePlugin.logError("TraceSubSystem", e); //$NON-NLS-1$
 297         }
 298
 299         return trace;
 300     }
 301
 302     /*
 303      * Retrieves the providers from the remote system.
 304      */
 305     private ProviderResource[] createProviders() throws SystemMessageException {
 306         ProviderResource[] providers = null;
 307         try {
 308
 309             final ILttControllerService service = getControllerService();
 310
 311             // Create future task
 312             providers = new TCFTask<ProviderResource[]>() {
 313                 @Override
 314                 public void run() {
 315
 316                     // Get provider using Lttng controller service proxy
 317                     service.getProviders(new ILttControllerService.DoneGetProviders() {
 318
 319                         @Override
 320                         public void doneGetProviders(IToken token, Exception error, String[] str) {
 321                             if (error != null) {
 322                                 // Notify with error
 323                                 error(error);
 324                                 return;
 325                             }
 326
 327                             // Create provider list
 328                             ProviderResource[] providers = new ProviderResource[str.length];
 329
 330                             for (int i = 0; i < str.length; i++) {
 331                                 ProviderResource tempProvider = new ProviderResource(TraceSubSystem.this);
 332                                 tempProvider.setName(str[i]);
 333                                 providers[i] = tempProvider;
 334                             }
 335
 336                             // Notify with provider list
 337                             done(providers);
 338                         }
 339                     });
 340                 }}.get(TraceControlConstants.DEFAULT_TCF_TASK_TIMEOUT, TimeUnit.SECONDS);
 341         } catch (Exception e) {
 342             if (e instanceof SystemMessageException) throw (SystemMessageException)e;
 343             throw new SystemMessageException(Activator.getDefault().getMessage(e));
 344         }
 345
 346         for (int i = 0; i < providers.length; i++) {
 347             createTargets(providers[i]);
 348         }
 349
 350         return providers;
 351     }
 352
 353     /*
 354      * Retrieves the targets for given provider from the remote system.
 355      */
 356     private TargetResource[] createTargets(final ProviderResource provider) throws SystemMessageException {
 357         TargetResource[] targets;
 358         try {
 359             final ILttControllerService service = getControllerService();
 360
 361             // Create future task
 362             targets = new TCFTask<TargetResource[]>() {
 363                 @Override
 364                 public void run() {
 365
 366                     // Get targets using Lttng controller service proxy
 367                     service.getTargets(provider.getName(), new ILttControllerService.DoneGetTargets() {
 368
 369                         @Override
 370                         public void doneGetTargets(IToken token, Exception error, String[] str) {
 371                             if (error != null) {
 372                                 // Notify with error
 373                                 error(error);
 374                                 return;
 375                             }
 376
 377                             // Create targets
 378                             TargetResource[] targets = new TargetResource[str.length];
 379                             for (int i = 0; i < str.length; i++) {
 380                                 TargetResource tempTarget = new TargetResource(TraceSubSystem.this);
 381                                 tempTarget.setName(str[i]);
 382                                 tempTarget.setParent(provider);
 383                                 targets[i] = tempTarget;
 384                             }
 385                             // Notify with target list
 386                             done(targets);
 387                         }
 388                     });
 389                 }}.get(TraceControlConstants.DEFAULT_TCF_TASK_TIMEOUT, TimeUnit.SECONDS);
 390         } catch (Exception e) {
 391                 provider.setTargets(new TargetResource[0]);
 392             if (e instanceof SystemMessageException) throw (SystemMessageException)e;
 393             throw new SystemMessageException(Activator.getDefault().getMessage(e));
 394         }
 395
 396         provider.setTargets(targets);
 397         for (int i = 0; i < targets.length; i++) {
 398                 if (targets[i].getParent().getName().equals(LttngConstants.Lttng_Provider_Kernel)) {
 399                     createTraces(targets[i]);
 400                 }
 401         }
 402
 403         return targets;
 404     }
 405
 406     /*
 407      * Retrieves the trace instances for a given target from the remote system.
 408      */
 409     private TraceResource[] createTraces(final TargetResource target) throws SystemMessageException {
 410         TraceResource[] traces;
 411         try {
 412             final ILttControllerService service = getControllerService();
 413
 414             // Create future task
 415             traces = new TCFTask<TraceResource[]>() {
 416                 @Override
 417                 public void run() {
 418                     // Get targets using Lttng controller service proxy
 419                     service.getTraces(target.getParent().getName(), target.getName(), new ILttControllerService.DoneGetTraces() {
 420
 421                         @Override
 422                         public void doneGetTraces(IToken token, Exception error, String[] str) {
 423                             if (error != null) {
 424                                 // Notify with error
 425                                 error(error);
 426                                 return;
 427                             }
 428
 429                             // Create trace list
 430                             TraceResource[] traces = new TraceResource[str.length];
 431                             for (int i = 0; i < str.length; i++) {
 432                                 TraceResource trace = new TraceResource(TraceSubSystem.this, service);
 433                                 trace.setName(str[i]);
 434                                 trace.setParent(target);
 435                                 trace.setTraceState(TraceState.CREATED);
 436                                 traces[i] = trace;
 437                             }
 438
 439                             // Notify with trace list
 440                             done(traces);
 441                         }
 442                     });
 443                 }}.get(TraceControlConstants.DEFAULT_TCF_TASK_TIMEOUT, TimeUnit.SECONDS);
 444         } catch (Exception e) {
 445             target.setTraces(new TraceResource[0]);
 446             if (e instanceof SystemMessageException) throw (SystemMessageException)e;
 447             throw new SystemMessageException(Activator.getDefault().getMessage(e));
 448         }
 449
 450         target.setTraces(traces);
 451
 452         // get active trace information (is only supported for kernel traces)
 453         createTraceConfigurations(target, traces);
 454         return traces;
 455     }
 456
 457     /*
 458      * Retrieves the trace configurations for the given trace from the remote system.
 459      */
 460     private void createTraceConfigurations(final TargetResource target, TraceResource[] traces) throws SystemMessageException {
 461         if (!target.isUst() && (traces.length > 0)) {
 462             // get active traces
 463             String[] activeTraceNames;
 464             try {
 465                 final ILttControllerService service = getControllerService();
 466                 activeTraceNames = new TCFTask<String[]>() {
 467                     @Override
 468                     public void run() {
 469                         // Get targets using Lttng controller service proxy
 470                         service.getActiveTraces(target.getParent().getName(), target.getName(), new ILttControllerService.DoneGetActiveTraces() {
 471
 472                             @Override
 473                             public void doneGetActiveTraces(IToken token, Exception error, String[] str) {
 474                                 if (error != null) {
 475                                     // Notify with error
 476                                     error(error);
 477                                     return;
 478                                 }
 479
 480                                 // Notify with active trace list
 481                                 done(str);
 482                             }
 483                         });
 484                     }}.get(TraceControlConstants.DEFAULT_TCF_TASK_TIMEOUT, TimeUnit.SECONDS);
 485             } catch (Exception e) {
 486                 if (e instanceof SystemMessageException) throw (SystemMessageException)e;
 487                 throw new SystemMessageException(Activator.getDefault().getMessage(e));
 488             }
 489
 490             // get active trace information
 491             for (int j = 0; j < activeTraceNames.length; j++) {
 492                 final TraceResource trace = target.getTrace(activeTraceNames[j]);
 493                 if (trace != null) {
 494                     // get trace info
 495                     TraceConfig traceConfig;
 496
 497                     try {
 498                         final ILttControllerService service = getControllerService();
 499                         traceConfig = new TCFTask<TraceConfig>() {
 500                             @Override
 501                             public void run() {
 502                                 // Get targets using Lttng controller service proxy
 503                                 service.getActiveTraceInfo(target.getParent().getName(), target.getName(), trace.getName(), new ILttControllerService.DoneGetActiveTraceInfo() {
 504
 505                                     @Override
 506                                     public void doneGetActiveTraceInfo(IToken token, Exception error, String[] strArray) {
 507                                         if (error != null) {
 508                                             // Notify with error
 509                                             error(error);
 510                                             return;
 511                                         }
 512
 513                                         TraceConfig config = new TraceConfig();
 514                                         config.setTraceName(trace.getName());
 515                                         config.setTraceTransport(TraceControlConstants.Lttng_Trace_Transport_Relay);
 516                                         config.setIsAppend(false);
 517                                         for (String pair : strArray) {
 518                                             String[] pairArray = pair.split(LttngConstants.Lttng_Control_GetActiveTraceInfoSeparator);
 519                                             if (pairArray.length != 2) {
 520                                                 continue;
 521                                             }
 522                                             String param = pairArray[0];
 523                                             String value = pairArray[1];
 524                                             if (param.equals(TraceControlConstants.ACTIVE_TRACE_INFO_PARAM_DESTINATION)) {
 525                                                 if (value.startsWith(TraceControlConstants.ACTIVE_TRACE_INFO_DESTINATION_PREFIX_LOCAL)) {
 526                                                     config.setNetworkTrace(false);
 527                                                     config.setTracePath(value.substring(TraceControlConstants.ACTIVE_TRACE_INFO_DESTINATION_PREFIX_LOCAL.length()));
 528                                                 } else if (value.startsWith(TraceControlConstants.ACTIVE_TRACE_INFO_DESTINATION_PREFIX_NETWORK)) {
 529                                                     config.setNetworkTrace(true);
 530                                                     config.setTracePath(value.substring(TraceControlConstants.ACTIVE_TRACE_INFO_DESTINATION_PREFIX_NETWORK.length()));
 531                                                 }
 532                                             } else if (param.equals(TraceControlConstants.ACTIVE_TRACE_INFO_PARAM_NUM_THREAD)) {
 533                                                 config.setNumChannel(Integer.valueOf(value));
 534                                             } else if (param.equals(TraceControlConstants.ACTIVE_TRACE_INFO_PARAM_NORMAL_ONLY)) {
 535                                                 if (value.equals(Boolean.toString(true))) {
 536                                                     config.setMode(TraceConfig.NORMAL_MODE);
 537                                                 }
 538                                             } else if (param.equals(TraceControlConstants.ACTIVE_TRACE_INFO_PARAM_FLIGHT_ONLY)) {
 539                                                 if (value.equals(Boolean.toString(true))) {
 540                                                     config.setMode(TraceConfig.FLIGHT_RECORDER_MODE);
 541                                                 }
 542                                             } else if (param.equals(TraceControlConstants.ACTIVE_TRACE_INFO_PARAM_ENABLED)) {
 543                                                 if (value.equals(Boolean.toString(true))) {
 544                                                     trace.setTraceState(TraceState.STARTED);
 545                                                 } else {
 546                                                     trace.setTraceState(TraceState.PAUSED);
 547                                                 }
 548                                             }
 549                                         }
 550
 551                                         // Notify with active trace list
 552                                         done(config);
 553                                     }
 554                                 });
 555                             }}.get(TraceControlConstants.DEFAULT_TCF_TASK_TIMEOUT, TimeUnit.SECONDS);
 556                         trace.setTraceConfig(traceConfig);
 557                         if (traceConfig != null) {
 558                             if (traceConfig.isNetworkTrace()) {
 559                                 // stop and restart the network transfer since TCF channel may be different
 560                                 if (fProviders == null) { // do this only on startup, not on refresh
 561                                     restartTraceNetwork(service, trace, traceConfig);
 562                                 }
 563                                 LiveTraceManager.setLiveTrace(traceConfig.getTracePath(), true);
 564                             }
 565                         }
 566                     } catch (Exception e) {
 567                         if (e instanceof SystemMessageException) throw (SystemMessageException)e;
 568                         throw new SystemMessageException(Activator.getDefault().getMessage(e));
 569                     }
 570                 }
 571             }
 572         }
 573     }
 574
 575     /*
 576      * (non-Javadoc)
 577      * @see org.eclipse.rse.core.subsystems.ICommunicationsListener#communicationsStateChange(org.eclipse.rse.core.subsystems.CommunicationsEvent)
 578      */
 579     @Override
 580     public void communicationsStateChange(CommunicationsEvent e) {
 581         switch (e.getState())
 582         {
 583         case CommunicationsEvent.BEFORE_CONNECT :
 584             break;
 585         case CommunicationsEvent.AFTER_CONNECT :
 586             break;
 587         case CommunicationsEvent.BEFORE_DISCONNECT :
 588
 589             try {
 590                 final TraceResource[] traces = getAllTraces();
 591
 592                 StringBuffer traceNames = new StringBuffer("");  //$NON-NLS-1$
 593                 String filler = ""; //$NON-NLS-1$
 594                 for (int j = 0; j < traces.length; j++) {
 595                     // For network traces, ask user to pause tracing
 596                     if (traces[j].isNetworkTraceAndStarted()) {
 597                         traceNames.append(filler);
 598                         traceNames.append(traces[j].getName());
 599                     }
 600                     filler = ", "; //$NON-NLS-1$
 601                 }
 602                 if (!"".equals(traceNames.toString())) { //$NON-NLS-1$
 603                     final String finalTraceNames = traceNames.toString();
 604                     Display.getDefault().syncExec(new Runnable() {
 605
 606                         @Override
 607                         public void run() {
 608                             MessageDialog.openWarning(Display.getDefault().getActiveShell(), Messages.Ltt_ShutdownWarning, Messages.Ltt_NetworkTraceRunningWarning + ":\n" + finalTraceNames); //$NON-NLS-1$
 609
 610                             // Pause tracing
 611                             PauseTrace pauseAction = new PauseTrace();
 612                             pauseAction.setSelectedTraces(new ArrayList<TraceResource>(Arrays.asList(traces)));
 613                             pauseAction.run(null);
 614                             try {
 615                                 Thread.sleep(2000); // allow time for target to pause traces before disconnecting the channel
 616                             } catch (InterruptedException e) {
 617                             }
 618                         }
 619                     });
 620                 }
 621
 622                 if (fProviders != null) {
 623                     // reset all providers and it's children
 624                     for (int i = 0; i < fProviders.length; i++) {
 625                         fProviders[i].removeAllTargets();
 626                     }
 627                     fProviders = null;
 628                 }
 629
 630             } catch (SystemMessageException ex) {
 631                 SystemBasePlugin.logError("TraceSubSystem", ex); //$NON-NLS-1$
 632             }
 633             break;
 634         case CommunicationsEvent.AFTER_DISCONNECT :
 635             getConnectorService().removeCommunicationsListener(this);
 636             break;
 637         case CommunicationsEvent.CONNECTION_ERROR :
 638             // TODO notify user about the lost connection ?!
 639             getConnectorService().removeCommunicationsListener(this);
 640             try {
 641                 this.disconnect();
 642             } catch (Exception e1) {
 643                 // Nothing to do
 644             }
 645             break;
 646         default :
 647             break;
 648         }
 649     }
 650
 651     /*
 652      * (non-Javadoc)
 653      * @see org.eclipse.rse.core.subsystems.ICommunicationsListener#isPassiveCommunicationsListener()
 654      */
 655     @Override
 656     public boolean isPassiveCommunicationsListener() {
 657         return true;
 658     }
 659
 660     /**
 661      * Returns the trace controller service.
 662      *
 663      * @return trace controller service
 664      * @throws Exception
 665      */
 666     public LttControllerServiceProxy getControllerService() throws Exception {
 667         return ((TraceConnectorService)getConnectorService()).getControllerService();
 668     }
 669
 670     /*
 671      * Stop and restart the network transfer. Only normal channels are written while trace is started.
 672      */
 673     private void restartTraceNetwork(final ILttControllerService service, final TraceResource trace, final TraceConfig traceConfig) throws Exception {
 674         File newDir = new File(traceConfig.getTracePath());
 675         if (!newDir.exists()) {
 676             boolean created = newDir.mkdirs();
 677             if (!created) {
 678                 throw new Exception(Messages.Lttng_Control_ErrorCreateTracePath + ": " + traceConfig.getTracePath()); //$NON-NLS-1$
 679             }
 680             if (traceConfig.getProject() != null) {
 681                 ImportToProject.linkTrace(getShell(), trace, traceConfig.getProject(), traceConfig.getTraceName());
 682             }
 683         }
 684
 685         // stop the previous lttd
 686         boolean ok = new TCFTask<Boolean>() {
 687             @Override
 688             public void run() {
 689
 690                 // Setup trace transport using Lttng controller service proxy
 691                 service.stopWriteTraceNetwork(trace.getParent().getParent().getName(),
 692                         trace.getParent().getName(),
 693                         traceConfig.getTraceName(),
 694                         new ILttControllerService.DoneStopWriteTraceNetwork() {
 695
 696                     @Override
 697                     public void doneStopWriteTraceNetwork(IToken token, Exception error, Object str) {
 698                         if (error != null) {
 699                             // Notify with error
 700                             error(error);
 701                             return;
 702                         }
 703
 704                         // Notify about success
 705                         done(true);
 706                     }
 707                 });
 708             }}.get(TraceControlConstants.DEFAULT_TCF_TASK_TIMEOUT, TimeUnit.SECONDS);
 709
 710         if (!ok) {
 711             return;
 712         }
 713
 714         // lttd will only perform the shutdown after stopWriteTraceNetwork
 715         // when it receives the next on_read_subbuffer callback
 716
 717         if (trace.getTraceState() == TraceState.PAUSED) {
 718             // we need to start the trace to make sure that the network transfer is stopped
 719             ok = new TCFTask<Boolean>() {
 720                 @Override
 721                 public void run() {
 722
 723                     // Start the trace
 724                     service.startTrace(trace.getParent().getParent().getName(),
 725                             trace.getParent().getName(),
 726                             traceConfig.getTraceName(),
 727                             new ILttControllerService.DoneStartTrace() {
 728
 729                         @Override
 730                         public void doneStartTrace(IToken token, Exception error, Object str) {
 731                             if (error != null) {
 732                                 // Notify with error
 733                                 error(error);
 734                                 return;
 735                             }
 736
 737                             // Notify about success
 738                             done(true);
 739                         }
 740                     });
 741                 }}.get(TraceControlConstants.DEFAULT_TCF_TASK_TIMEOUT, TimeUnit.SECONDS);
 742
 743             if (!ok) {
 744                 return;
 745             }
 746
 747             trace.setTraceState(TraceState.STARTED);
 748
 749             // wait for the lttd shutdown
 750             Thread.sleep(1000);
 751
 752             // return to paused state
 753             ok = new TCFTask<Boolean>() {
 754                 @Override
 755                 public void run() {
 756
 757                     // Pause the trace
 758                     service.pauseTrace(trace.getParent().getParent().getName(),
 759                             trace.getParent().getName(),
 760                             traceConfig.getTraceName(),
 761                             new ILttControllerService.DonePauseTrace() {
 762
 763                         @Override
 764                         public void donePauseTrace(IToken token, Exception error, Object str) {
 765                             if (error != null) {
 766                                 // Notify with error
 767                                 error(error);
 768                                 return;
 769                             }
 770
 771                             // Notify about success
 772                             done(true);
 773                         }
 774                     });
 775                 }}.get(TraceControlConstants.DEFAULT_TCF_TASK_TIMEOUT, TimeUnit.SECONDS);
 776
 777             if (!ok) {
 778                 return;
 779             }
 780
 781             trace.setTraceState(TraceState.PAUSED);
 782
 783         } else {
 784             // wait for the lttd shutdown
 785             Thread.sleep(1000);
 786         }
 787
 788         // start a new lttd
 789         new TCFTask<Boolean>() {
 790             @Override
 791             public void run() {
 792
 793                 // Setup trace transport using Lttng controller service proxy
 794                 service.writeTraceNetwork(trace.getParent().getParent().getName(),
 795                         trace.getParent().getName(),
 796                         traceConfig.getTraceName(),
 797                         traceConfig.getTracePath(),
 798                         traceConfig.getNumChannel(),
 799                         traceConfig.getIsAppend(),
 800                         false,
 801                         true, // write only normal channels
 802                         new ILttControllerService.DoneWriteTraceNetwork() {
 803
 804                     @Override
 805                     public void doneWriteTraceNetwork(IToken token, Exception error, Object str) {
 806                         if (error != null) {
 807                             // Notify with error
 808                             error(error);
 809                             return;
 810                         }
 811
 812                         // Notify about success
 813                         done(true);
 814                     }
 815                 });
 816             }}.get(TraceControlConstants.DEFAULT_TCF_TASK_TIMEOUT, TimeUnit.SECONDS);
 817     }
 818 }