projects / deliverable / tracecompass.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Fix for streaming and reconnection. Added standalone releng for lttng.
[deliverable/tracecompass.git] / org.eclipse.linuxtools.lttng.ui / src / org / eclipse / linuxtools / lttng / ui / tracecontrol / subsystems / TraceSubSystem.java
CommitLineData
e8d771d5
BH		 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 *******************************************************************************/
14package org.eclipse.linuxtools.lttng.ui.tracecontrol.subsystems;
15
1b70b6dc 16import java.io.File;
e8d771d5
BH		 17import java.util.ArrayList;
18import java.util.Arrays;
19import java.util.Vector;
20import java.util.concurrent.TimeUnit;
21
22import org.eclipse.core.runtime.IProgressMonitor;
23import org.eclipse.jface.dialogs.MessageDialog;
6c13869b
FC		 24import org.eclipse.linuxtools.lttng.core.LttngConstants;
25import org.eclipse.linuxtools.lttng.core.tracecontrol.model.ProviderResource;
26import org.eclipse.linuxtools.lttng.core.tracecontrol.model.TargetResource;
27import org.eclipse.linuxtools.lttng.core.tracecontrol.model.TraceResource;
28import org.eclipse.linuxtools.lttng.core.tracecontrol.model.TraceResource.TraceState;
29import org.eclipse.linuxtools.lttng.core.tracecontrol.model.config.TraceConfig;
30import org.eclipse.linuxtools.lttng.core.tracecontrol.service.ILttControllerService;
31import org.eclipse.linuxtools.lttng.core.tracecontrol.service.LttControllerServiceProxy;
1b70b6dc 32import org.eclipse.linuxtools.lttng.core.tracecontrol.utility.LiveTraceManager;
e8d771d5 33import org.eclipse.linuxtools.lttng.ui.LTTngUiPlugin;
e8d771d5 34import org.eclipse.linuxtools.lttng.ui.tracecontrol.Messages;
1b70b6dc
PT		 35import org.eclipse.linuxtools.lttng.ui.tracecontrol.TraceControlConstants;
36import org.eclipse.linuxtools.lttng.ui.tracecontrol.actions.ImportToProject;
e8d771d5
BH		 37import org.eclipse.linuxtools.lttng.ui.tracecontrol.actions.PauseTrace;
38import org.eclipse.linuxtools.lttng.ui.tracecontrol.connectorservice.TraceConnectorService;
39import org.eclipse.rse.core.events.ISystemResourceChangeEvents;
40import org.eclipse.rse.core.events.SystemResourceChangeEvent;
41import org.eclipse.rse.core.filters.ISystemFilter;
42import org.eclipse.rse.core.filters.ISystemFilterPoolReference;
43import org.eclipse.rse.core.model.IHost;
44import org.eclipse.rse.core.model.ISystemMessageObject;
45import org.eclipse.rse.core.model.ISystemRegistry;
46import org.eclipse.rse.core.model.SystemMessageObject;
47import org.eclipse.rse.core.model.SystemStartHere;
48import org.eclipse.rse.core.subsystems.CommunicationsEvent;
49import org.eclipse.rse.core.subsystems.ICommunicationsListener;
50import org.eclipse.rse.core.subsystems.IConnectorService;
51import org.eclipse.rse.core.subsystems.SubSystem;
52import org.eclipse.rse.services.clientserver.NamePatternMatcher;
53import org.eclipse.rse.services.clientserver.messages.SystemMessageException;
54import org.eclipse.rse.ui.SystemBasePlugin;
55import org.eclipse.swt.widgets.Display;
56import org.eclipse.tm.tcf.protocol.IToken;
57import org.eclipse.tm.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 */
67public class TraceSubSystem extends SubSystem implements ICommunicationsListener {
68
69 // ------------------------------------------------------------------------
70 // Attributes
71 // ------------------------------------------------------------------------
72 private ProviderResource[] fProviders; // master list of Providers
73
74 // ------------------------------------------------------------------------
75 // Constructors
76 // ------------------------------------------------------------------------
77 /**
78 * @param host
79 * @param connectorService
80 */
81 public TraceSubSystem(IHost host, IConnectorService connectorService) {
82 super(host, connectorService);
83 }
84
85 // ------------------------------------------------------------------------
86 // Operations
87 // ------------------------------------------------------------------------
88
89 /*
90 * (non-Javadoc)
91 * @see org.eclipse.rse.core.subsystems.SubSystem#initializeSubSystem(org.eclipse.core.runtime.IProgressMonitor)
92 */
93 @Override
94 public void initializeSubSystem(IProgressMonitor monitor) {
95 getConnectorService().addCommunicationsListener(this);
96 }
97
98 /*
99 * (non-Javadoc)
100 * @see org.eclipse.rse.core.subsystems.SubSystem#uninitializeSubSystem(org.eclipse.core.runtime.IProgressMonitor)
101 */
102 @Override
103 public void uninitializeSubSystem(IProgressMonitor monitor) {
104 }
105
106 /*
107 * (non-Javadoc)
108 * @see org.eclipse.rse.core.subsystems.SubSystem#getObjectWithAbsoluteName(java.lang.String)
109 *
110 * For drag and drop, and clipboard support of remote objects.
111 *
112 * 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
113 * the real object. By default this returns null.
114 */
115 @Override
116 public Object getObjectWithAbsoluteName(String key) {
117 return null;
118 }
119
120 /*
121 * (non-Javadoc)
122 * @see org.eclipse.rse.core.subsystems.SubSystem#internalResolveFilterString(java.lang.String, org.eclipse.core.runtime.IProgressMonitor)
123 */
124 @Override
125 protected Object[] internalResolveFilterString(String filterString, IProgressMonitor monitor) throws java.lang.reflect.InvocationTargetException, java.lang.InterruptedException {
126
127 ProviderResource[] allProviders;
128
129 try {
130 allProviders = getAllProviders();
131 } catch (SystemMessageException e) {
132 SystemBasePlugin.logError("TraceSubSystem", e); //$NON-NLS-1$
133 Object[] children = new SystemMessageObject[1];
134 children[0] = new SystemMessageObject(e.getSystemMessage(), ISystemMessageObject.MSGTYPE_ERROR, null);
135 return children;
136 }
137
138 // Now, subset master list, based on filter string...
139 NamePatternMatcher subsetter = new NamePatternMatcher(filterString);
140 Vector<ProviderResource> v = new Vector<ProviderResource>();
141 for (int idx = 0; idx < allProviders.length; idx++) {
142 if (subsetter.matches(allProviders[idx].getName())) {
143 v.addElement(allProviders[idx]);
144 }
145 }
146 return allProviders;
147 }
148 /*
149 * (non-Javadoc)
150 * @see org.eclipse.rse.core.subsystems.SubSystem#internalResolveFilterString(java.lang.Object, java.lang.String, org.eclipse.core.runtime.IProgressMonitor)
151 */
152 @Override
153 protected Object[] internalResolveFilterString(Object parent, String filterString, IProgressMonitor monitor) throws java.lang.reflect.InvocationTargetException, java.lang.InterruptedException {
154 return null;
155 }
156
157 /* (non-Javadoc)
158 * @see org.eclipse.rse.core.subsystems.SubSystem#filterEventFilterCreated(java.lang.Object, org.eclipse.rse.core.filters.ISystemFilter)
159 */
160 @Override
161 public void filterEventFilterCreated(Object selectedObject, ISystemFilter newFilter) {
162 super.filterEventFilterCreated(selectedObject, newFilter);
163 ISystemRegistry registry = SystemStartHere.getSystemRegistry();
164 registry.fireEvent(new SystemResourceChangeEvent(this, ISystemResourceChangeEvents.EVENT_REFRESH, null));
165 }
166
167 /* (non-Javadoc)
168 * @see org.eclipse.rse.core.subsystems.SubSystem#filterEventFilterPoolReferenceCreated(org.eclipse.rse.core.filters.ISystemFilterPoolReference)
169 */
170 @Override
171 public void filterEventFilterPoolReferenceCreated(ISystemFilterPoolReference newPoolRef) {
172 super.filterEventFilterPoolReferenceCreated(newPoolRef);
173 if (getSystemFilterPoolReferenceManager().getSystemFilterPoolReferenceCount() == 1) {
174 ISystemRegistry registry = SystemStartHere.getSystemRegistry();
175 registry.fireEvent(new SystemResourceChangeEvent(this, ISystemResourceChangeEvents.EVENT_REFRESH, null));
176 }
177 }
178
179 /**
180 * Retrieves all provider resources from the remote system and updates local references.
181 *
182 * @return provider resources
183 * @throws SystemMessageException
184 * @throws InterruptedException
185 */
186 public ProviderResource[] getAllProviders() throws SystemMessageException, InterruptedException {
187 ProviderResource[] providers = createProviders();
188 if (fProviders == null) {
189 fProviders = providers;
190 }
191 else {
192 for (int i = 0; i < fProviders.length; i++) {
193 for (int j = 0; j < providers.length; j++) {
194 if(fProviders[i].getName().equals(providers[j].getName())) {
195 // Check if all targets already exist
196 fProviders[i].refreshTargets(providers[j].getTargets());
197 }
198 }
199 }
200 }
201 return fProviders;
202 }
203
204 /**
205 * Get the list of all targets.
206 *
207 * @return targets The list of targets.
208 * @throws SystemMessageException
209 */
210 public TargetResource[] getAllTargets() throws SystemMessageException {
211 ArrayList<TargetResource> targets = new ArrayList<TargetResource>();
212 if (fProviders != null) {
213 for (int i = 0; i < fProviders.length; i++) {
214 targets.addAll(Arrays.asList(fProviders[i].getTargets()));
215 }
216 }
217 return targets.toArray(new TargetResource[0]);
218 }
219
220 /**
221 * Get the list of all traces.
222 *
223 * @return traces The list of traces.
224 * @throws SystemMessageException
225 */
226 public TraceResource[] getAllTraces() throws SystemMessageException {
227 ArrayList<TraceResource> traces = new ArrayList<TraceResource>();
228 if (fProviders != null) {
229 for (int i = 0; i < fProviders.length; i++) {
230 ProviderResource provider = fProviders[i];
231 int numTargets = provider.getTargets().length;
232 for (int j = 0; j < numTargets; j++) {
233 TargetResource target = provider.getTargets()[j];
234 if (provider.getName().equals(LttngConstants.Lttng_Provider_Kernel)) {
235 traces.addAll(Arrays.asList(target.getTraces()));
236 }
237 }
238 }
239 }
240 return traces.toArray(new TraceResource[0]);
241 }
242
243 /**
244 * Get the list of all traces for given provider and target.
245 *
246 * @param provider
247 * @param target
248 * @returns trace resources
249 */
250 public TraceResource[] getAllTraces(String providerName, String targetName) throws SystemMessageException {
251 ArrayList<TraceResource> traces = new ArrayList<TraceResource>();
252 ProviderResource selectedProvider = null;
253 if (fProviders != null) {
254 for (int i = 0; i < fProviders.length; i++) {
255 ProviderResource provider = fProviders[i];
256 if (provider.getName().equals(providerName)) {
257 selectedProvider = fProviders[i];
258 break;
259 }
260 }
261
262 if (selectedProvider != null) {
263 int numTargets = selectedProvider.getTargets().length;
264 for (int j = 0; j < numTargets; j++) {
265 TargetResource target = selectedProvider.getTargets()[j];
266 if (target.getName().equals(targetName)) {
267 traces.addAll(Arrays.asList(target.getTraces()));
268 break;
269 }
270 }
271 }
272 }
273 return traces.toArray(new TraceResource[0]);
274 }
275
276 /**
277 * Finds a trace resource within a given provider and target for a given trace name
278 *
279 * @param targetName - target name to be searched
280 * @param traceName - trace name to be searched
281 * @return trace resource or null (if not found)
282 */
283 public TraceResource findTrace(String providerName, String targetName, String traceName) {
284 TraceResource trace = null;
285 TraceResource[] traces;
286 try {
287 traces = getAllTraces(providerName, targetName);
288 for (int i = 0; i < traces.length; i++) {
289 if (traces[i].getName().equals(traceName)) {
290 trace = traces[i];
291 break;
292 }
293 }
294 } catch (SystemMessageException e) {
295 SystemBasePlugin.logError("TraceSubSystem", e); //$NON-NLS-1$
296 }
297
298 return trace;
299 }
300
301 /*
302 * Retrieves the providers from the remote system.
303 */
304 private ProviderResource[] createProviders() throws SystemMessageException {
305 ProviderResource[] providers = null;
306 try {
307
308 final ILttControllerService service = getControllerService();
309
310 // Create future task
311 providers = new TCFTask<ProviderResource[]>() {
312 @Override
313 public void run() {
314
315 // Get provider using Lttng controller service proxy
316 service.getProviders(new ILttControllerService.DoneGetProviders() {
317
318 @Override
319 public void doneGetProviders(IToken token, Exception error, String[] str) {
320 if (error != null) {
321 // Notify with error
322 error(error);
323 return;
324 }
325
326 // Create provider list
327 ProviderResource[] providers = new ProviderResource[str.length];
328
329 for (int i = 0; i < str.length; i++) {
330 ProviderResource tempProvider = new ProviderResource(TraceSubSystem.this);
331 tempProvider.setName(str[i]);
332 providers[i] = tempProvider;
333 }
334
335 // Notify with provider list
336 done(providers);
337 }
338 });
339 }}.get(TraceControlConstants.DEFAULT_TCF_TASK_TIMEOUT, TimeUnit.SECONDS);
340 } catch (Exception e) {
341 if (e instanceof SystemMessageException) throw (SystemMessageException)e;
342 throw new SystemMessageException(LTTngUiPlugin.getDefault().getMessage(e));
343 }
344
345 for (int i = 0; i < providers.length; i++) {
346 createTargets(providers[i]);
347 }
348
349 return providers;
350 }
351
352 /*
353 * Retrieves the targets for given provider from the remote system.
354 */
355 private TargetResource[] createTargets(final ProviderResource provider) throws SystemMessageException {
356 TargetResource[] targets;
357 try {
358 final ILttControllerService service = getControllerService();
359
360 // Create future task
361 targets = new TCFTask<TargetResource[]>() {
362 @Override
363 public void run() {
364
365 // Get targets using Lttng controller service proxy
366 service.getTargets(provider.getName(), new ILttControllerService.DoneGetTargets() {
367
368 @Override
369 public void doneGetTargets(IToken token, Exception error, String[] str) {
370 if (error != null) {
371 // Notify with error
372 error(error);
373 return;
374 }
375
376 // Create targets
377 TargetResource[] targets = new TargetResource[str.length];
378 for (int i = 0; i < str.length; i++) {
379 TargetResource tempTarget = new TargetResource(TraceSubSystem.this);
380 tempTarget.setName(str[i]);
381 tempTarget.setParent(provider);
382 targets[i] = tempTarget;
383 }
384 // Notify with target list
385 done(targets);
386 }
387 });
388 }}.get(TraceControlConstants.DEFAULT_TCF_TASK_TIMEOUT, TimeUnit.SECONDS);
389 } catch (Exception e) {
390 provider.setTargets(new TargetResource[0]);
391 if (e instanceof SystemMessageException) throw (SystemMessageException)e;
392 throw new SystemMessageException(LTTngUiPlugin.getDefault().getMessage(e));
393 }
394
395 provider.setTargets(targets);
396 for (int i = 0; i < targets.length; i++) {
397 if (targets[i].getParent().getName().equals(LttngConstants.Lttng_Provider_Kernel)) {
398 createTraces(targets[i]);
399 }
400 }
401
402 return targets;
403 }
404
405 /*
406 * Retrieves the trace instances for a given target from the remote system.
407 */
408 private TraceResource[] createTraces(final TargetResource target) throws SystemMessageException {
409 TraceResource[] traces;
410 try {
411 final ILttControllerService service = getControllerService();
412
413 // Create future task
414 traces = new TCFTask<TraceResource[]>() {
415 @Override
416 public void run() {
417 // Get targets using Lttng controller service proxy
418 service.getTraces(target.getParent().getName(), target.getName(), new ILttControllerService.DoneGetTraces() {
419
420 @Override
421 public void doneGetTraces(IToken token, Exception error, String[] str) {
422 if (error != null) {
423 // Notify with error
424 error(error);
425 return;
426 }
427
428 // Create trace list
429 TraceResource[] traces = new TraceResource[str.length];
430 for (int i = 0; i < str.length; i++) {
a79913eb 431 TraceResource trace = new TraceResource(TraceSubSystem.this, service);
e8d771d5
BH		 432 trace.setName(str[i]);
433 trace.setParent(target);
434 trace.setTraceState(TraceState.CREATED);
435 traces[i] = trace;
436 }
437
438 // Notify with trace list
439 done(traces);
440 }
441 });
442 }}.get(TraceControlConstants.DEFAULT_TCF_TASK_TIMEOUT, TimeUnit.SECONDS);
443 } catch (Exception e) {
444 target.setTraces(new TraceResource[0]);
445 if (e instanceof SystemMessageException) throw (SystemMessageException)e;
446 throw new SystemMessageException(LTTngUiPlugin.getDefault().getMessage(e));
447 }
448
449 target.setTraces(traces);
450
451 // get active trace information (is only supported for kernel traces)
452 createTraceConfigurations(target, traces);
453 return traces;
454 }
455
456 /*
457 * Retrieves the trace configurations for the given trace from the remote system.
458 */
459 private void createTraceConfigurations(final TargetResource target, TraceResource[] traces) throws SystemMessageException {
460 if (!target.isUst() && (traces.length > 0)) {
461 // get active traces
462 String[] activeTraceNames;
463 try {
464 final ILttControllerService service = getControllerService();
465 activeTraceNames = new TCFTask<String[]>() {
466 @Override
467 public void run() {
468 // Get targets using Lttng controller service proxy
469 service.getActiveTraces(target.getParent().getName(), target.getName(), new ILttControllerService.DoneGetActiveTraces() {
470
471 @Override
472 public void doneGetActiveTraces(IToken token, Exception error, String[] str) {
473 if (error != null) {
474 // Notify with error
475 error(error);
476 return;
477 }
478
479 // Notify with active trace list
480 done(str);
481 }
482 });
483 }}.get(TraceControlConstants.DEFAULT_TCF_TASK_TIMEOUT, TimeUnit.SECONDS);
484 } catch (Exception e) {
485 if (e instanceof SystemMessageException) throw (SystemMessageException)e;
486 throw new SystemMessageException(LTTngUiPlugin.getDefault().getMessage(e));
487 }
488
489 // get active trace information
490 for (int j = 0; j < activeTraceNames.length; j++) {
491 final TraceResource trace = target.getTrace(activeTraceNames[j]);
492 if (trace != null) {
493 // get trace info
494 TraceConfig traceConfig;
495
e8d771d5
BH		 496 try {
497 final ILttControllerService service = getControllerService();
498 traceConfig = new TCFTask<TraceConfig>() {
499 @Override
500 public void run() {
501 // Get targets using Lttng controller service proxy
502 service.getActiveTraceInfo(target.getParent().getName(), target.getName(), trace.getName(), new ILttControllerService.DoneGetActiveTraceInfo() {
503
504 @Override
1b70b6dc 505 public void doneGetActiveTraceInfo(IToken token, Exception error, String[] strArray) {
e8d771d5
BH		 506 if (error != null) {
507 // Notify with error
508 error(error);
509 return;
510 }
511
512 TraceConfig config = new TraceConfig();
1b70b6dc
PT		 513 config.setTraceName(trace.getName());
514 config.setTraceTransport(TraceControlConstants.Lttng_Trace_Transport_Relay);
e8d771d5 515 config.setIsAppend(false);
1b70b6dc
PT		 516 for (String pair : strArray) {
517 String[] pairArray = pair.split(LttngConstants.Lttng_Control_GetActiveTraceInfoSeparator);
518 if (pairArray.length != 2) {
519 continue;
520 }
521 String param = pairArray[0];
522 String value = pairArray[1];
523 if (param.equals(TraceControlConstants.ACTIVE_TRACE_INFO_PARAM_DESTINATION)) {
524 if (value.startsWith(TraceControlConstants.ACTIVE_TRACE_INFO_DESTINATION_PREFIX_LOCAL)) {
525 config.setNetworkTrace(false);
526 config.setTracePath(value.substring(TraceControlConstants.ACTIVE_TRACE_INFO_DESTINATION_PREFIX_LOCAL.length()));
527 } else if (value.startsWith(TraceControlConstants.ACTIVE_TRACE_INFO_DESTINATION_PREFIX_NETWORK)) {
528 config.setNetworkTrace(true);
529 config.setTracePath(value.substring(TraceControlConstants.ACTIVE_TRACE_INFO_DESTINATION_PREFIX_NETWORK.length()));
530 }
531 } else if (param.equals(TraceControlConstants.ACTIVE_TRACE_INFO_PARAM_NUM_THREAD)) {
532 config.setNumChannel(Integer.valueOf(value));
533 } else if (param.equals(TraceControlConstants.ACTIVE_TRACE_INFO_PARAM_NORMAL_ONLY)) {
534 if (value.equals(Boolean.toString(true))) {
535 config.setMode(TraceConfig.NORMAL_MODE);
536 }
537 } else if (param.equals(TraceControlConstants.ACTIVE_TRACE_INFO_PARAM_FLIGHT_ONLY)) {
538 if (value.equals(Boolean.toString(true))) {
539 config.setMode(TraceConfig.FLIGHT_RECORDER_MODE);
540 }
541 } else if (param.equals(TraceControlConstants.ACTIVE_TRACE_INFO_PARAM_ENABLED)) {
542 if (value.equals(Boolean.toString(true))) {
543 trace.setTraceState(TraceState.STARTED);
544 } else {
545 trace.setTraceState(TraceState.PAUSED);
546 }
547 }
e8d771d5 548 }
e8d771d5 549
e8d771d5
BH		 550 // Notify with active trace list
551 done(config);
552 }
553 });
554 }}.get(TraceControlConstants.DEFAULT_TCF_TASK_TIMEOUT, TimeUnit.SECONDS);
1b70b6dc
PT		 555 trace.setTraceConfig(traceConfig);
556 if (traceConfig != null) {
557 if (traceConfig.isNetworkTrace()) {
558 // stop and restart the network transfer since TCF channel may be different
559 if (fProviders == null) { // do this only on startup, not on refresh
560 restartTraceNetwork(service, trace, traceConfig);
561 }
562 LiveTraceManager.setLiveTrace(traceConfig.getTracePath(), true);
563 }
564 }
e8d771d5
BH		 565 } catch (Exception e) {
566 if (e instanceof SystemMessageException) throw (SystemMessageException)e;
567 throw new SystemMessageException(LTTngUiPlugin.getDefault().getMessage(e));
568 }
e8d771d5
BH		 569 }
570 }
571 }
572 }
573
574 /*
575 * (non-Javadoc)
576 * @see org.eclipse.rse.core.subsystems.ICommunicationsListener#communicationsStateChange(org.eclipse.rse.core.subsystems.CommunicationsEvent)
577 */
578 @Override
579 public void communicationsStateChange(CommunicationsEvent e) {
580 switch (e.getState())
581 {
582 case CommunicationsEvent.BEFORE_CONNECT :
583 break;
584 case CommunicationsEvent.AFTER_CONNECT :
585 break;
586 case CommunicationsEvent.BEFORE_DISCONNECT :
587
588 try {
589 final TraceResource[] traces = getAllTraces();
590
591 StringBuffer traceNames = new StringBuffer(""); //$NON-NLS-1$
592 String filler = ""; //$NON-NLS-1$
593 for (int j = 0; j < traces.length; j++) {
594 // For network traces, ask user to pause tracing
595 if (traces[j].isNetworkTraceAndStarted()) {
596 traceNames.append(filler);
597 traceNames.append(traces[j].getName());
598 }
599 filler = ", "; //$NON-NLS-1$
600 }
601 if (!"".equals(traceNames.toString())) { //$NON-NLS-1$
602 final String finalTraceNames = traceNames.toString();
603 Display.getDefault().syncExec(new Runnable() {
604
605 @Override
606 public void run() {
607 MessageDialog.openWarning(Display.getDefault().getActiveShell(), Messages.Ltt_ShutdownWarning, Messages.Ltt_NetworkTraceRunningWarning + ":\n" + finalTraceNames); //$NON-NLS-1$
608
609 // Pause tracing
610 PauseTrace pauseAction = new PauseTrace();
611 pauseAction.setSelectedTraces(new ArrayList<TraceResource>(Arrays.asList(traces)));
612 pauseAction.run(null);
e4dc0a9a
FC		 613 try {
614 Thread.sleep(2000); // allow time for target to pause traces before disconnecting the channel
615 } catch (InterruptedException e) {
616 e.printStackTrace();
617 }
e8d771d5
BH		 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 }
1b70b6dc
PT		 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 }
e8d771d5 818}
Tracecompass - Deliverables
This page took 0.055427 seconds and 5 git commands to generate.