1 /**********************************************************************
2 * Copyright (c) 2012, 2014 Ericsson
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
10 * Patrick Tasse - Initial API and implementation
11 * Bernd Hufmann - Updated using Executor Framework
12 **********************************************************************/
13 package org
.eclipse
.tracecompass
.internal
.lttng2
.control
.ui
.views
.remote
;
15 import java
.io
.BufferedReader
;
16 import java
.io
.IOException
;
17 import java
.io
.InputStreamReader
;
18 import java
.util
.ArrayList
;
19 import java
.util
.Random
;
20 import java
.util
.concurrent
.Callable
;
21 import java
.util
.concurrent
.CancellationException
;
22 import java
.util
.concurrent
.ExecutorService
;
23 import java
.util
.concurrent
.Executors
;
24 import java
.util
.concurrent
.FutureTask
;
25 import java
.util
.concurrent
.TimeUnit
;
26 import java
.util
.concurrent
.TimeoutException
;
28 import org
.eclipse
.core
.commands
.ExecutionException
;
29 import org
.eclipse
.core
.runtime
.IProgressMonitor
;
30 import org
.eclipse
.core
.runtime
.NullProgressMonitor
;
31 import org
.eclipse
.rse
.services
.shells
.HostShellProcessAdapter
;
32 import org
.eclipse
.rse
.services
.shells
.IHostShell
;
33 import org
.eclipse
.rse
.services
.shells
.IShellService
;
34 import org
.eclipse
.tracecompass
.internal
.lttng2
.control
.ui
.views
.messages
.Messages
;
35 import org
.eclipse
.tracecompass
.internal
.lttng2
.control
.ui
.views
.preferences
.ControlPreferences
;
39 * Implementation of remote command execution using RSE's shell service.
42 * @author Patrick Tasse
43 * @author Bernd Hufmann
45 public class CommandShell
implements ICommandShell
{
47 // ------------------------------------------------------------------------
49 // ------------------------------------------------------------------------
51 /** Sub-string to be echo'ed when running command in shell, used to indicate that the command has finished running */
52 public static final String DONE_MARKUP_STRING
= "--RSE:donedonedone:--"; //$NON-NLS-1$
54 /** Sub-string to be echoed when running a command in shell. */
55 public static final String BEGIN_END_TAG
= "BEGIN-END-TAG:"; //$NON-NLS-1$
57 /** Command delimiter for shell */
58 public static final String CMD_DELIMITER
= "\n"; //$NON-NLS-1$
60 /** Shell "echo" command */
61 public static final String SHELL_ECHO_CMD
= " echo "; //$NON-NLS-1$
63 /** Default command separator */
64 public static final char CMD_SEPARATOR
= ';';
66 // ------------------------------------------------------------------------
68 // ------------------------------------------------------------------------
69 private IRemoteSystemProxy fProxy
= null;
70 private IHostShell fHostShell
= null;
71 private BufferedReader fInputBufferReader
= null;
72 private BufferedReader fErrorBufferReader
= null;
73 private final ExecutorService fExecutor
= Executors
.newFixedThreadPool(1);
74 private boolean fIsConnected
= false;
75 private final Random fRandom
= new Random(System
.currentTimeMillis());
76 private int fReturnValue
;
78 // ------------------------------------------------------------------------
80 // ------------------------------------------------------------------------
83 * Create a new command shell
86 * The RSE proxy for this shell
88 public CommandShell(IRemoteSystemProxy proxy
) {
92 // ------------------------------------------------------------------------
94 // ------------------------------------------------------------------------
97 public void connect() throws ExecutionException
{
98 IShellService shellService
= fProxy
.getShellService();
101 String
[] env
= new String
[0];
103 if (fProxy
.isLocal()) {
104 env
= shellService
.getHostEnvironment();
107 fHostShell
= shellService
.launchShell("", env
, new NullProgressMonitor()); //$NON-NLS-1$
108 p
= new HostShellProcessAdapter(fHostShell
);
109 } catch (Exception e
) {
110 throw new ExecutionException(Messages
.TraceControl_CommandShellError
, e
);
112 fInputBufferReader
= new BufferedReader(new InputStreamReader(p
.getInputStream()));
113 fErrorBufferReader
= new BufferedReader(new InputStreamReader(p
.getErrorStream()));
118 public void disconnect() {
119 fIsConnected
= false;
121 fInputBufferReader
.close();
122 fErrorBufferReader
.close();
123 } catch (IOException e
) {
129 public ICommandResult
executeCommand(String command
, IProgressMonitor monitor
) throws ExecutionException
{
130 return executeCommand(command
, monitor
, true);
134 public ICommandResult
executeCommand(final String command
, final IProgressMonitor monitor
, final boolean checkReturnValue
) throws ExecutionException
{
136 FutureTask
<CommandResult
> future
= new FutureTask
<>(new Callable
<CommandResult
>() {
138 public CommandResult
call() throws IOException
, CancellationException
{
139 final ArrayList
<String
> result
= new ArrayList
<>();
140 final ArrayList
<String
> errorResult
= new ArrayList
<>();
142 synchronized (fHostShell
) {
143 // Initialize return value which will be updated in isAliasEchoResult()
146 int startAlias
= fRandom
.nextInt();
147 int endAlias
= fRandom
.nextInt();
148 fHostShell
.writeToShell(formatShellCommand(command
, startAlias
, endAlias
));
151 boolean isStartFound
= false;
152 while ((nextLine
= fInputBufferReader
.readLine()) != null) {
154 if (monitor
.isCanceled()) {
156 throw new CancellationException();
159 // check if line contains echoed start alias
160 if (isAliasEchoResult(nextLine
, startAlias
, true)) {
165 // check if line contains is the end mark-up. This will retrieve also
166 // the return value of the actual command.
167 if (isAliasEchoResult(nextLine
, endAlias
, false)) {
172 // 1) start hasn't been found or
173 // 2) line is an echo of the command or
174 // 3) line is an echo of the end mark-up
176 isCommandEcho(nextLine
, command
) ||
177 nextLine
.contains(getEchoResult(endAlias
)))
182 // Now it's time add to the result
183 result
.add(nextLine
);
186 // Read any left over output
189 // Read error stream output when command failed.
190 if (fReturnValue
!= 0) {
191 while(fErrorBufferReader
.ready()) {
192 if ((nextLine
= fErrorBufferReader
.readLine()) != null) {
193 errorResult
.add(nextLine
);
196 // Workaround if error stream is not available and stderr output is written
197 // in standard output above. This is true for the SshTerminalShell implementation.
198 if (errorResult
.isEmpty()) {
199 errorResult
.addAll(result
);
203 return new CommandResult(fReturnValue
, result
.toArray(new String
[result
.size()]), errorResult
.toArray(new String
[errorResult
.size()]));
207 fExecutor
.execute(future
);
210 return future
.get(ControlPreferences
.getInstance().getCommandTimeout(), TimeUnit
.SECONDS
);
211 } catch (java
.util
.concurrent
.ExecutionException ex
) {
212 throw new ExecutionException(Messages
.TraceControl_ExecutionFailure
, ex
);
213 } catch (InterruptedException ex
) {
214 throw new ExecutionException(Messages
.TraceControl_ExecutionCancelled
, ex
);
215 } catch (TimeoutException ex
) {
216 throw new ExecutionException(Messages
.TraceControl_ExecutionTimeout
, ex
);
219 throw new ExecutionException(Messages
.TraceControl_ShellNotConnected
, null);
222 // ------------------------------------------------------------------------
224 // ------------------------------------------------------------------------
226 * Flushes the buffer reader
227 * @throws IOException
229 private void flushInput() throws IOException
{
230 char[] cbuf
= new char[1];
231 while (fInputBufferReader
.ready()) {
232 if (fInputBufferReader
.read(cbuf
, 0, 1) == -1) {
239 * Format the command to be sent into the shell command with start and end marker strings.
240 * The start marker is need to know when the actual command output starts. The end marker
241 * string is needed so we can tell that end of output has been reached.
243 * @param cmd The actual command
244 * @param startAlias The command alias for start marker
245 * @param endAlias The command alias for end marker
246 * @return formatted command string
248 private static String
formatShellCommand(String cmd
, int startAlias
, int endAlias
) {
249 if (cmd
== null || cmd
.equals("")) { //$NON-NLS-1$
252 StringBuffer formattedCommand
= new StringBuffer();
253 // Make multi-line command.
254 // Wrap actual command with start marker and end marker to wrap actual command.
255 formattedCommand
.append(getEchoCmd(startAlias
));
256 formattedCommand
.append(CMD_DELIMITER
);
257 formattedCommand
.append(cmd
);
258 formattedCommand
.append(CMD_DELIMITER
);
259 formattedCommand
.append(getEchoCmd(endAlias
));
260 formattedCommand
.append(CMD_DELIMITER
);
261 return formattedCommand
.toString();
265 * Creates a echo command line in the format: echo <start tag> <alias> <end tag> $?
267 * @param alias The command alias integer to be included in the echoed message.
268 * @return the echo command line
270 private static String
getEchoCmd(int alias
) {
271 return SHELL_ECHO_CMD
+ getEchoResult(alias
) + "$?"; //$NON-NLS-1$
275 * Creates the expected result for a given command alias:
276 * <start tag> <alias> <end tag> $?
278 * @param alias The command alias integer to be included in the echoed message.
279 * @return the expected echo result
281 private static String
getEchoResult(int alias
) {
282 return BEGIN_END_TAG
+ String
.valueOf(alias
) + DONE_MARKUP_STRING
;
286 * Verifies if given command line contains a command alias echo result.
288 * @param line The output line to test.
289 * @param alias The command alias
290 * @param checkReturnValue <code>true</code> to retrieve command result (previous command) <code>false</code>
291 * @return <code>true</code> if output line is a command alias echo result else <code>false</code>
293 private boolean isAliasEchoResult(String line
, int alias
, boolean checkReturnValue
) {
294 String expected
= getEchoResult(alias
);
295 if (line
.startsWith(expected
)) {
296 if (!checkReturnValue
) {
298 int k
= Integer
.valueOf(line
.substring(expected
.length()));
300 } catch (NumberFormatException e
) {
306 int index
= line
.indexOf(expected
);
307 if ((index
> 0) && (line
.indexOf(SHELL_ECHO_CMD
) == -1)) {
315 * Verifies if output line is an echo of the given command line. If the
316 * output line is longer then the maximum line lengths (e.g. for ssh), the
317 * shell adds a line break character. This method takes this in
318 * consideration by comparing the command line without any whitespaces.
321 * The output line to verify
323 * The command executed
324 * @return <code>true</code> if it's an echoed command line else
327 @SuppressWarnings("nls")
328 private static boolean isCommandEcho(String line
, String cmd
) {
329 String s1
= line
.replaceAll("\\s","");
330 String s2
= cmd
.replaceAll("\\s","");
331 s2
= s2
.replaceAll("(\\*)", "(\\\\*)");
332 String patternStr
= ".*(" + s2
+")$";
333 return s1
.matches(patternStr
);