diff options
Diffstat (limited to 'plugins/org.yocto.remote.utils/src/org/yocto/remote')
18 files changed, 2149 insertions, 0 deletions
diff --git a/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/Activator.java b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/Activator.java new file mode 100644 index 0000000..da66a3e --- /dev/null +++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/Activator.java | |||
@@ -0,0 +1,62 @@ | |||
1 | /******************************************************************************* | ||
2 | * Copyright (c) 2013 Intel Corporation. | ||
3 | * All rights reserved. This program and the accompanying materials | ||
4 | * are made available under the terms of the Eclipse Public License v1.0 | ||
5 | * which accompanies this distribution, and is available at | ||
6 | * http://www.eclipse.org/legal/epl-v10.html | ||
7 | * | ||
8 | * Contributors: | ||
9 | * Intel - initial API and implementation | ||
10 | *******************************************************************************/ | ||
11 | package org.yocto.remote.utils; | ||
12 | |||
13 | import org.eclipse.ui.plugin.AbstractUIPlugin; | ||
14 | import org.osgi.framework.BundleContext; | ||
15 | |||
16 | /** | ||
17 | * The activator class controls the plug-in life cycle | ||
18 | */ | ||
19 | public class Activator extends AbstractUIPlugin { | ||
20 | |||
21 | // The plug-in ID | ||
22 | public static final String PLUGIN_ID = "org.yocto.remote.utils"; //$NON-NLS-1$ | ||
23 | |||
24 | // The shared instance | ||
25 | private static Activator plugin; | ||
26 | |||
27 | /** | ||
28 | * The constructor | ||
29 | */ | ||
30 | public Activator() { | ||
31 | } | ||
32 | |||
33 | /* | ||
34 | * (non-Javadoc) | ||
35 | * @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext) | ||
36 | */ | ||
37 | @Override | ||
38 | public void start(BundleContext context) throws Exception { | ||
39 | super.start(context); | ||
40 | plugin = this; | ||
41 | } | ||
42 | |||
43 | /* | ||
44 | * (non-Javadoc) | ||
45 | * @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext) | ||
46 | */ | ||
47 | @Override | ||
48 | public void stop(BundleContext context) throws Exception { | ||
49 | plugin = null; | ||
50 | super.stop(context); | ||
51 | } | ||
52 | |||
53 | /** | ||
54 | * Returns the shared instance | ||
55 | * | ||
56 | * @return the shared instance | ||
57 | */ | ||
58 | public static Activator getDefault() { | ||
59 | return plugin; | ||
60 | } | ||
61 | |||
62 | } | ||
diff --git a/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/CommandOutputProcessor.java b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/CommandOutputProcessor.java new file mode 100644 index 0000000..081e6d4 --- /dev/null +++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/CommandOutputProcessor.java | |||
@@ -0,0 +1,43 @@ | |||
1 | /******************************************************************************* | ||
2 | * Copyright (c) 2013 Intel Corporation. | ||
3 | * All rights reserved. This program and the accompanying materials | ||
4 | * are made available under the terms of the Eclipse Public License v1.0 | ||
5 | * which accompanies this distribution, and is available at | ||
6 | * http://www.eclipse.org/legal/epl-v10.html | ||
7 | * | ||
8 | * Contributors: | ||
9 | * Ioana Grigoropol(Intel) - initial API and implementation | ||
10 | *******************************************************************************/ | ||
11 | package org.yocto.remote.utils; | ||
12 | |||
13 | import org.eclipse.core.runtime.IProgressMonitor; | ||
14 | import org.eclipse.rse.services.shells.IHostShell; | ||
15 | |||
16 | public class CommandOutputProcessor extends OutputProcessor { | ||
17 | |||
18 | public CommandOutputProcessor(IProgressMonitor monitor, | ||
19 | IHostShell hostShell, CommandResponseHandler cmdHandler, String task) { | ||
20 | super(monitor, hostShell, cmdHandler, task); | ||
21 | } | ||
22 | |||
23 | @Override | ||
24 | protected boolean isErrChStop(char ch) { | ||
25 | return (ch == '\n'); | ||
26 | } | ||
27 | |||
28 | @Override | ||
29 | protected boolean isOutChStop(char ch) { | ||
30 | return (ch == '\n'); | ||
31 | } | ||
32 | |||
33 | @Override | ||
34 | protected void processOutputBufferLine(char ch, String str) { | ||
35 | processBuffer.addOutputLine(str); | ||
36 | } | ||
37 | |||
38 | @Override | ||
39 | protected void processErrorBufferLine(char ch, String str) { | ||
40 | processBuffer.addErrorLine(str); | ||
41 | } | ||
42 | |||
43 | } | ||
diff --git a/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/CommandResponseHandler.java b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/CommandResponseHandler.java new file mode 100644 index 0000000..f02fbfa --- /dev/null +++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/CommandResponseHandler.java | |||
@@ -0,0 +1,44 @@ | |||
1 | /******************************************************************************* | ||
2 | * Copyright (c) 2013 Intel Corporation. | ||
3 | * All rights reserved. This program and the accompanying materials | ||
4 | * are made available under the terms of the Eclipse Public License v1.0 | ||
5 | * which accompanies this distribution, and is available at | ||
6 | * http://www.eclipse.org/legal/epl-v10.html | ||
7 | * | ||
8 | * Contributors: | ||
9 | * Ioana Grigoropol(Intel) - initial API and implementation | ||
10 | *******************************************************************************/ | ||
11 | package org.yocto.remote.utils; | ||
12 | |||
13 | import org.eclipse.ui.console.MessageConsole; | ||
14 | import org.eclipse.ui.console.MessageConsoleStream; | ||
15 | |||
16 | public class CommandResponseHandler implements ICommandResponseHandler { | ||
17 | private MessageConsoleStream consoleStream; | ||
18 | private Boolean errorOccured = false; | ||
19 | |||
20 | public CommandResponseHandler(MessageConsole console) { | ||
21 | try { | ||
22 | this.consoleStream = console.newMessageStream(); | ||
23 | } catch (Exception e) { | ||
24 | e.printStackTrace(); | ||
25 | } | ||
26 | } | ||
27 | |||
28 | public Boolean hasError() { | ||
29 | return errorOccured; | ||
30 | } | ||
31 | |||
32 | @Override | ||
33 | public void response(String line, boolean isError) { | ||
34 | try { | ||
35 | if (isError) { | ||
36 | errorOccured = true; | ||
37 | } | ||
38 | consoleStream.println(line); | ||
39 | } catch (Exception e) { | ||
40 | e.printStackTrace(); | ||
41 | } | ||
42 | } | ||
43 | |||
44 | } \ No newline at end of file | ||
diff --git a/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/CommandRunnable.java b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/CommandRunnable.java new file mode 100644 index 0000000..8cbda18 --- /dev/null +++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/CommandRunnable.java | |||
@@ -0,0 +1,44 @@ | |||
1 | /******************************************************************************* | ||
2 | * Copyright (c) 2013 Intel Corporation. | ||
3 | * All rights reserved. This program and the accompanying materials | ||
4 | * are made available under the terms of the Eclipse Public License v1.0 | ||
5 | * which accompanies this distribution, and is available at | ||
6 | * http://www.eclipse.org/legal/epl-v10.html | ||
7 | * | ||
8 | * Contributors: | ||
9 | * Ioana Grigoropol(Intel) - initial API and implementation | ||
10 | *******************************************************************************/ | ||
11 | package org.yocto.remote.utils; | ||
12 | |||
13 | import org.eclipse.core.runtime.CoreException; | ||
14 | import org.eclipse.core.runtime.IProgressMonitor; | ||
15 | import org.eclipse.rse.core.model.IHost; | ||
16 | import org.eclipse.rse.services.shells.IHostShell; | ||
17 | |||
18 | public class CommandRunnable implements Runnable{ | ||
19 | private IHostShell hostShell; | ||
20 | private final IHost connection; | ||
21 | private final YoctoCommand cmd; | ||
22 | private final IProgressMonitor monitor; | ||
23 | private final CommandResponseHandler cmdHandler; | ||
24 | |||
25 | CommandRunnable(IHost connection, YoctoCommand cmd, IProgressMonitor monitor){ | ||
26 | this.connection = connection; | ||
27 | this.cmdHandler = RemoteHelper.getCommandHandler(connection); | ||
28 | this.cmd = cmd; | ||
29 | this.monitor = monitor; | ||
30 | this.hostShell = null; | ||
31 | } | ||
32 | @Override | ||
33 | public void run() { | ||
34 | try { | ||
35 | hostShell = RemoteHelper.runCommandRemote(connection, cmd, monitor); | ||
36 | cmd.setProcessBuffer(RemoteHelper.processOutput(monitor, hostShell, cmdHandler)); | ||
37 | } catch (CoreException e) { | ||
38 | e.printStackTrace(); | ||
39 | } catch (Exception e) { | ||
40 | e.printStackTrace(); | ||
41 | } | ||
42 | } | ||
43 | |||
44 | } | ||
diff --git a/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/CommonHelper.java b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/CommonHelper.java new file mode 100644 index 0000000..23afd38 --- /dev/null +++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/CommonHelper.java | |||
@@ -0,0 +1,46 @@ | |||
1 | /******************************************************************************* | ||
2 | * Copyright (c) 2013 Intel Corporation. | ||
3 | * All rights reserved. This program and the accompanying materials | ||
4 | * are made available under the terms of the Eclipse Public License v1.0 | ||
5 | * which accompanies this distribution, and is available at | ||
6 | * http://www.eclipse.org/legal/epl-v10.html | ||
7 | * | ||
8 | * Contributors: | ||
9 | * Intel - initial API and implementation | ||
10 | *******************************************************************************/ | ||
11 | package org.yocto.remote.utils; | ||
12 | |||
13 | import org.eclipse.core.runtime.IStatus; | ||
14 | import org.eclipse.core.runtime.Status; | ||
15 | import org.eclipse.jface.dialogs.ErrorDialog; | ||
16 | import org.eclipse.swt.widgets.Display; | ||
17 | |||
18 | public class CommonHelper { | ||
19 | |||
20 | static public boolean isExecAvail(String exec) { | ||
21 | boolean ret = false; | ||
22 | try { | ||
23 | Process p = Runtime.getRuntime().exec(new String[] {"which", exec}); | ||
24 | p.waitFor(); | ||
25 | if(p.exitValue() == 0) { | ||
26 | ret = true; | ||
27 | } | ||
28 | } catch (Exception e) { | ||
29 | e.printStackTrace(); | ||
30 | } | ||
31 | return ret; | ||
32 | } | ||
33 | |||
34 | public static void showErrorDialog(final String dialogTitle, final String errorMessage, final String reason) { | ||
35 | //needs to be run in the ui thread otherwise swt throws invalid thread access | ||
36 | Display.getDefault().syncExec(new Runnable() { | ||
37 | @Override | ||
38 | public void run() { | ||
39 | ErrorDialog.openError(null, dialogTitle, errorMessage, | ||
40 | new Status(IStatus.ERROR,Activator.PLUGIN_ID,reason)); | ||
41 | } | ||
42 | }); | ||
43 | |||
44 | } | ||
45 | |||
46 | } | ||
diff --git a/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/ConsoleHelper.java b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/ConsoleHelper.java new file mode 100644 index 0000000..9c5c244 --- /dev/null +++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/ConsoleHelper.java | |||
@@ -0,0 +1,38 @@ | |||
1 | /******************************************************************************* | ||
2 | * Copyright (c) 2013 Intel Corporation. | ||
3 | * All rights reserved. This program and the accompanying materials | ||
4 | * are made available under the terms of the Eclipse Public License v1.0 | ||
5 | * which accompanies this distribution, and is available at | ||
6 | * http://www.eclipse.org/legal/epl-v10.html | ||
7 | * | ||
8 | * Contributors: | ||
9 | * Ioana Grigoropol(Intel) - initial API and implementation | ||
10 | *******************************************************************************/ | ||
11 | package org.yocto.remote.utils; | ||
12 | |||
13 | import org.eclipse.swt.widgets.Display; | ||
14 | import org.eclipse.ui.console.ConsolePlugin; | ||
15 | import org.eclipse.ui.console.IConsole; | ||
16 | import org.eclipse.ui.console.IConsoleManager; | ||
17 | import org.eclipse.ui.console.MessageConsole; | ||
18 | |||
19 | public class ConsoleHelper { | ||
20 | public static final String YOCTO_CONSOLE = "Yocto Project Console"; | ||
21 | |||
22 | public static MessageConsole findConsole(String name) { | ||
23 | ConsolePlugin plugin = ConsolePlugin.getDefault(); | ||
24 | IConsoleManager conMan = plugin.getConsoleManager(); | ||
25 | IConsole[] existing = conMan.getConsoles(); | ||
26 | for (int i = 0; i < existing.length; i++) | ||
27 | if (name.equals(existing[i].getName())) | ||
28 | return (MessageConsole) existing[i]; | ||
29 | // no console found, so create a new one | ||
30 | MessageConsole myConsole = new MessageConsole(name, null); | ||
31 | conMan.addConsoles(new IConsole[] { myConsole }); | ||
32 | return myConsole; | ||
33 | } | ||
34 | |||
35 | public static void showConsole(MessageConsole console){ | ||
36 | Display.getDefault().syncExec(new ConsoleRunnable(console)); | ||
37 | } | ||
38 | } | ||
diff --git a/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/ConsoleRunnable.java b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/ConsoleRunnable.java new file mode 100644 index 0000000..e5fe666 --- /dev/null +++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/ConsoleRunnable.java | |||
@@ -0,0 +1,47 @@ | |||
1 | /******************************************************************************* | ||
2 | * Copyright (c) 2013 Intel Corporation. | ||
3 | * All rights reserved. This program and the accompanying materials | ||
4 | * are made available under the terms of the Eclipse Public License v1.0 | ||
5 | * which accompanies this distribution, and is available at | ||
6 | * http://www.eclipse.org/legal/epl-v10.html | ||
7 | * | ||
8 | * Contributors: | ||
9 | * Ioana Grigoropol(Intel) - initial API and implementation | ||
10 | *******************************************************************************/ | ||
11 | package org.yocto.remote.utils; | ||
12 | |||
13 | import org.eclipse.ui.IWorkbench; | ||
14 | import org.eclipse.ui.IWorkbenchPage; | ||
15 | import org.eclipse.ui.IWorkbenchWindow; | ||
16 | import org.eclipse.ui.PlatformUI; | ||
17 | import org.eclipse.ui.console.IConsoleConstants; | ||
18 | import org.eclipse.ui.console.IConsoleView; | ||
19 | import org.eclipse.ui.console.MessageConsole; | ||
20 | |||
21 | public class ConsoleRunnable implements Runnable{ | ||
22 | MessageConsole console; | ||
23 | ConsoleRunnable (MessageConsole console){ | ||
24 | this.console = console; | ||
25 | } | ||
26 | @Override | ||
27 | public void run() { | ||
28 | IWorkbench wb = PlatformUI.getWorkbench(); | ||
29 | if (wb == null) | ||
30 | return; | ||
31 | IWorkbenchWindow win = wb.getActiveWorkbenchWindow(); | ||
32 | if (win == null) | ||
33 | return; | ||
34 | IWorkbenchPage page = win.getActivePage(); | ||
35 | if (page == null) | ||
36 | return; | ||
37 | String id = IConsoleConstants.ID_CONSOLE_VIEW; | ||
38 | try { | ||
39 | IConsoleView view = (IConsoleView) page.showView(id); | ||
40 | if (view == null) | ||
41 | return; | ||
42 | view.display(console); | ||
43 | } catch (Exception e) { | ||
44 | e.printStackTrace(); | ||
45 | } | ||
46 | } | ||
47 | } \ No newline at end of file | ||
diff --git a/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/DialogRunnable.java b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/DialogRunnable.java new file mode 100644 index 0000000..5fbab76 --- /dev/null +++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/DialogRunnable.java | |||
@@ -0,0 +1,26 @@ | |||
1 | package org.yocto.remote.utils; | ||
2 | |||
3 | import org.eclipse.jface.dialogs.MessageDialog; | ||
4 | |||
5 | public class DialogRunnable implements Runnable{ | ||
6 | int type = 0; | ||
7 | boolean result; | ||
8 | public static final int QUESTION = 1; | ||
9 | public static final int ERROR = 2; | ||
10 | String title; | ||
11 | String message; | ||
12 | |||
13 | DialogRunnable(String title, String message, int type){ | ||
14 | this.title = title; | ||
15 | this.message = message; | ||
16 | this.type = type; | ||
17 | } | ||
18 | @Override | ||
19 | public void run() { | ||
20 | if (type == QUESTION) { | ||
21 | result = MessageDialog.openQuestion(null, title, message); | ||
22 | } else if (type == ERROR) { | ||
23 | MessageDialog.openError(null, title, message); | ||
24 | } | ||
25 | } | ||
26 | } \ No newline at end of file | ||
diff --git a/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/ICommandResponseHandler.java b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/ICommandResponseHandler.java new file mode 100644 index 0000000..193d57c --- /dev/null +++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/ICommandResponseHandler.java | |||
@@ -0,0 +1,16 @@ | |||
1 | /***************************************************************************** | ||
2 | * Copyright (c) 2013 Ken Gilmer, Intel Corporation | ||
3 | * All rights reserved. This program and the accompanying materials | ||
4 | * are made available under the terms of the Eclipse Public License v1.0 | ||
5 | * which accompanies this distribution, and is available at | ||
6 | * http://www.eclipse.org/legal/epl-v10.html | ||
7 | * | ||
8 | * Contributors: | ||
9 | * Ken Gilmer - initial API and implementation | ||
10 | * Ioana Grigoropol (Intel) - move to separate remote utilities plugin | ||
11 | *******************************************************************************/ | ||
12 | package org.yocto.remote.utils; | ||
13 | |||
14 | public interface ICommandResponseHandler { | ||
15 | public void response(String line, boolean isError); | ||
16 | } | ||
diff --git a/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/Messages.java b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/Messages.java new file mode 100644 index 0000000..fc696d6 --- /dev/null +++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/Messages.java | |||
@@ -0,0 +1,35 @@ | |||
1 | /******************************************************************************* | ||
2 | * Copyright (c) 2013 Intel Corporation. | ||
3 | * All rights reserved. This program and the accompanying materials | ||
4 | * are made available under the terms of the Eclipse Public License v1.0 | ||
5 | * which accompanies this distribution, and is available at | ||
6 | * http://www.eclipse.org/legal/epl-v10.html | ||
7 | * | ||
8 | * Contributors: | ||
9 | * Intel - initial API and implementation | ||
10 | *******************************************************************************/ | ||
11 | package org.yocto.remote.utils; | ||
12 | |||
13 | import org.eclipse.osgi.util.NLS; | ||
14 | |||
15 | public class Messages extends NLS { | ||
16 | |||
17 | private static final String BUNDLE_NAME = "org.yocto.remote.utils.messages"; //$NON-NLS-1$ | ||
18 | |||
19 | public static String ErrorNoSubsystem; | ||
20 | public static String ErrorConnectSubsystem; | ||
21 | |||
22 | public static String InfoDownload; | ||
23 | public static String InfoUpload; | ||
24 | |||
25 | public static String RemoteShellExec_1; | ||
26 | public static String RemoteShellExec_2; | ||
27 | |||
28 | static { | ||
29 | // initialize resource bundle | ||
30 | NLS.initializeMessages(BUNDLE_NAME, Messages.class); | ||
31 | } | ||
32 | |||
33 | private Messages() { | ||
34 | } | ||
35 | } | ||
diff --git a/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/OutputProcessor.java b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/OutputProcessor.java new file mode 100644 index 0000000..401a782 --- /dev/null +++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/OutputProcessor.java | |||
@@ -0,0 +1,112 @@ | |||
1 | /******************************************************************************* | ||
2 | * Copyright (c) 2013 Intel Corporation. | ||
3 | * All rights reserved. This program and the accompanying materials | ||
4 | * are made available under the terms of the Eclipse Public License v1.0 | ||
5 | * which accompanies this distribution, and is available at | ||
6 | * http://www.eclipse.org/legal/epl-v10.html | ||
7 | * | ||
8 | * Contributors: | ||
9 | * Ioana Grigoropol(Intel) - initial API and implementation | ||
10 | *******************************************************************************/ | ||
11 | package org.yocto.remote.utils; | ||
12 | |||
13 | import java.io.BufferedReader; | ||
14 | import java.io.IOException; | ||
15 | import java.io.InputStreamReader; | ||
16 | import java.util.concurrent.locks.Lock; | ||
17 | |||
18 | import org.eclipse.core.runtime.IProgressMonitor; | ||
19 | import org.eclipse.rse.internal.services.local.shells.LocalHostShell; | ||
20 | import org.eclipse.rse.internal.services.shells.TerminalServiceHostShell; | ||
21 | import org.eclipse.rse.services.shells.HostShellProcessAdapter; | ||
22 | import org.eclipse.rse.services.shells.IHostShell; | ||
23 | |||
24 | public abstract class OutputProcessor{ | ||
25 | private static final int ERROR_BUFFER = 1; | ||
26 | private static final int OUTPUT_BUFFER = 2; | ||
27 | protected String task; | ||
28 | protected ProcessStreamBuffer processBuffer; | ||
29 | protected IHostShell hostShell; | ||
30 | protected CommandResponseHandler cmdHandler; | ||
31 | protected IProgressMonitor monitor; | ||
32 | |||
33 | public OutputProcessor(IProgressMonitor monitor, IHostShell hostShell, CommandResponseHandler cmdHandler, String task){ | ||
34 | this.monitor = monitor; | ||
35 | this.hostShell = hostShell; | ||
36 | this.processBuffer = new ProcessStreamBuffer(hostShell instanceof TerminalServiceHostShell); | ||
37 | this.cmdHandler = cmdHandler; | ||
38 | this.task = task; | ||
39 | } | ||
40 | public ProcessStreamBuffer processOutput() throws Exception{ | ||
41 | if (hostShell == null) | ||
42 | throw new Exception("An error has occured while trying to run remote command!"); | ||
43 | monitor.beginTask(this.task, RemoteHelper.TOTALWORKLOAD); | ||
44 | Lock lock = null; | ||
45 | if (hostShell instanceof LocalHostShell) { | ||
46 | lock = ((LocalHostShell)hostShell).getLock(); | ||
47 | lock.lock(); | ||
48 | } | ||
49 | BufferedReader inbr = null; | ||
50 | BufferedReader errbr = null; | ||
51 | |||
52 | if (hostShell instanceof LocalHostShell) { | ||
53 | inbr = ((LocalHostShell)hostShell).getReader(false); | ||
54 | errbr = ((LocalHostShell)hostShell).getReader(true); | ||
55 | } else { | ||
56 | Process p = new HostShellProcessAdapter(hostShell); | ||
57 | inbr = new BufferedReader(new InputStreamReader(p.getInputStream())); | ||
58 | errbr = new BufferedReader(new InputStreamReader(p.getErrorStream())); | ||
59 | } | ||
60 | boolean cancel = false; | ||
61 | while (!cancel) { | ||
62 | if(monitor.isCanceled()) { | ||
63 | cancel = true; | ||
64 | if (lock != null) | ||
65 | lock.unlock(); | ||
66 | throw new InterruptedException("User Cancelled"); | ||
67 | } | ||
68 | processBuffer(errbr, ERROR_BUFFER); | ||
69 | processBuffer(inbr, OUTPUT_BUFFER); | ||
70 | cancel = true; | ||
71 | } | ||
72 | if (lock != null) | ||
73 | lock.unlock(); | ||
74 | return processBuffer; | ||
75 | } | ||
76 | protected abstract boolean isErrChStop(char ch); | ||
77 | protected abstract boolean isOutChStop(char ch); | ||
78 | protected boolean isChStop(char ch, int type){ | ||
79 | if (type == ERROR_BUFFER) | ||
80 | return isErrChStop(ch); | ||
81 | else if(type == OUTPUT_BUFFER) | ||
82 | return isOutChStop(ch); | ||
83 | return false; | ||
84 | } | ||
85 | protected abstract void processOutputBufferLine(char ch, String str); | ||
86 | protected abstract void processErrorBufferLine(char ch, String str); | ||
87 | protected void processBufferLine(String str, char ch, int type){ | ||
88 | if (type == ERROR_BUFFER) | ||
89 | processErrorBufferLine(ch, str); | ||
90 | else if(type == OUTPUT_BUFFER) | ||
91 | processOutputBufferLine(ch, str); | ||
92 | } | ||
93 | protected void processBuffer(BufferedReader br, int type) throws IOException{ | ||
94 | StringBuffer buffer = new StringBuffer(); | ||
95 | int c; | ||
96 | if (br != null) | ||
97 | while ((c = br.read()) != -1) { | ||
98 | char ch = (char) c; | ||
99 | buffer.append(ch); | ||
100 | if (isChStop(ch, type)){ | ||
101 | String str = buffer.toString(); | ||
102 | processBufferLine(str, ch, type); | ||
103 | System.out.println(str); | ||
104 | if (str.trim().equals(RemoteHelper.TERMINATOR)) { | ||
105 | break; | ||
106 | } | ||
107 | cmdHandler.response(str, false); | ||
108 | buffer.delete(0, buffer.length()); | ||
109 | } | ||
110 | } | ||
111 | } | ||
112 | } \ No newline at end of file | ||
diff --git a/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/ProcessStreamBuffer.java b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/ProcessStreamBuffer.java new file mode 100644 index 0000000..111f607 --- /dev/null +++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/ProcessStreamBuffer.java | |||
@@ -0,0 +1,87 @@ | |||
1 | /******************************************************************************* | ||
2 | * Copyright (c) 2013 Intel Corporation. | ||
3 | * All rights reserved. This program and the accompanying materials | ||
4 | * are made available under the terms of the Eclipse Public License v1.0 | ||
5 | * which accompanies this distribution, and is available at | ||
6 | * http://www.eclipse.org/legal/epl-v10.html | ||
7 | * | ||
8 | * Contributors: | ||
9 | * Intel - initial API and implementation | ||
10 | *******************************************************************************/ | ||
11 | package org.yocto.remote.utils; | ||
12 | |||
13 | import java.util.ArrayList; | ||
14 | import java.util.List; | ||
15 | import java.util.regex.Pattern; | ||
16 | |||
17 | public class ProcessStreamBuffer { | ||
18 | private static final String WHITESPACES = "\\s+"; | ||
19 | List<String> errorLines; | ||
20 | List<String> outputLines; | ||
21 | boolean isTerminal; | ||
22 | |||
23 | ProcessStreamBuffer(boolean isTerminal){ | ||
24 | this.isTerminal = isTerminal; | ||
25 | errorLines = new ArrayList<String>(); | ||
26 | outputLines = new ArrayList<String>(); | ||
27 | } | ||
28 | |||
29 | public void addErrorLine(String line){ | ||
30 | errorLines.add(line); | ||
31 | } | ||
32 | public void addOutputLine(String line){ | ||
33 | outputLines.add(line); | ||
34 | } | ||
35 | |||
36 | public List<String> getOutputLines(){ | ||
37 | return outputLines; | ||
38 | } | ||
39 | |||
40 | public List<String> getErrorLines(){ | ||
41 | return errorLines; | ||
42 | } | ||
43 | |||
44 | public String getMergedOutputLines(){ | ||
45 | String returnVal = ""; | ||
46 | for (int i = 0; i < outputLines.size(); i++) { | ||
47 | String line = outputLines.get(i); | ||
48 | returnVal += line; | ||
49 | if (outputLines.size() > 1 && i != outputLines.size() - 1) | ||
50 | returnVal += "\n"; | ||
51 | } | ||
52 | return returnVal; | ||
53 | } | ||
54 | |||
55 | public boolean hasErrors() { | ||
56 | return errorLines.size() != 0; | ||
57 | } | ||
58 | |||
59 | public String getLastOutputLineContaining(String str) { | ||
60 | if (!errorLines.isEmpty()) | ||
61 | return null; | ||
62 | for (int i = outputLines.size() - 1; i >= 0; i--){ | ||
63 | String line = outputLines.get(i); | ||
64 | if (line.replaceAll(WHITESPACES, "").contains(str.replaceAll(WHITESPACES, ""))) | ||
65 | return line; | ||
66 | } | ||
67 | return null; | ||
68 | } | ||
69 | |||
70 | public String getOutputLineContaining(String arg, String pattern) { | ||
71 | List<String> lines = null; | ||
72 | if (isTerminal) | ||
73 | lines = errorLines; | ||
74 | else | ||
75 | lines = outputLines; | ||
76 | for (int i = lines.size() - 1; i >= 0; i--){ | ||
77 | String line = lines.get(i); | ||
78 | if (line.contains(arg)) { | ||
79 | String[] tokens = line.split("\\s+"); | ||
80 | if (Pattern.matches(pattern, tokens[0])) { | ||
81 | return tokens[0]; | ||
82 | } | ||
83 | } | ||
84 | } | ||
85 | return ""; | ||
86 | } | ||
87 | } | ||
diff --git a/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/RemoteHelper.java b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/RemoteHelper.java new file mode 100644 index 0000000..e0097ec --- /dev/null +++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/RemoteHelper.java | |||
@@ -0,0 +1,680 @@ | |||
1 | /******************************************************************************** | ||
2 | * Copyright (c) 2013 MontaVista Software, Inc and Others. | ||
3 | * This program and the accompanying materials are made available under the terms | ||
4 | * of the Eclipse Public License v1.0 which accompanies this distribution, and is | ||
5 | * available at http://www.eclipse.org/legal/epl-v10.html | ||
6 | * | ||
7 | * Contributors: | ||
8 | * Anna Dushistova (MontaVista) - initial API and implementation | ||
9 | * Lianhao Lu (Intel) - Modified to add other file operations. | ||
10 | * Ioana Grigoropol (Intel) - Separated remote functionality | ||
11 | ********************************************************************************/ | ||
12 | package org.yocto.remote.utils; | ||
13 | |||
14 | import java.io.BufferedInputStream; | ||
15 | import java.io.BufferedOutputStream; | ||
16 | import java.io.BufferedReader; | ||
17 | import java.io.File; | ||
18 | import java.io.FileInputStream; | ||
19 | import java.io.FileNotFoundException; | ||
20 | import java.io.FileOutputStream; | ||
21 | import java.io.FileReader; | ||
22 | import java.io.IOException; | ||
23 | import java.io.InputStream; | ||
24 | import java.io.PrintWriter; | ||
25 | import java.net.URI; | ||
26 | import java.net.URISyntaxException; | ||
27 | import java.nio.file.Files; | ||
28 | import java.util.ArrayList; | ||
29 | import java.util.Arrays; | ||
30 | import java.util.HashMap; | ||
31 | import java.util.Iterator; | ||
32 | import java.util.List; | ||
33 | import java.util.Map; | ||
34 | |||
35 | import org.eclipse.core.internal.filesystem.InternalFileSystemCore; | ||
36 | import org.eclipse.core.internal.resources.LocalMetaArea; | ||
37 | import org.eclipse.core.internal.resources.Workspace; | ||
38 | import org.eclipse.core.resources.ResourcesPlugin; | ||
39 | import org.eclipse.core.runtime.CoreException; | ||
40 | import org.eclipse.core.runtime.FileLocator; | ||
41 | import org.eclipse.core.runtime.IPath; | ||
42 | import org.eclipse.core.runtime.IProgressMonitor; | ||
43 | import org.eclipse.core.runtime.IStatus; | ||
44 | import org.eclipse.core.runtime.MultiStatus; | ||
45 | import org.eclipse.core.runtime.NullProgressMonitor; | ||
46 | import org.eclipse.core.runtime.Path; | ||
47 | import org.eclipse.core.runtime.Status; | ||
48 | import org.eclipse.core.runtime.SubProgressMonitor; | ||
49 | import org.eclipse.osgi.util.NLS; | ||
50 | import org.eclipse.rse.core.IRSECoreStatusCodes; | ||
51 | import org.eclipse.rse.core.IRSEInitListener; | ||
52 | import org.eclipse.rse.core.IRSESystemType; | ||
53 | import org.eclipse.rse.core.IRSEUserIdConstants; | ||
54 | import org.eclipse.rse.core.RSECorePlugin; | ||
55 | import org.eclipse.rse.core.model.IHost; | ||
56 | import org.eclipse.rse.core.model.ISubSystemConfigurationCategories; | ||
57 | import org.eclipse.rse.core.model.ISubSystemConfigurator; | ||
58 | import org.eclipse.rse.core.model.ISystemHostPool; | ||
59 | import org.eclipse.rse.core.model.ISystemRegistry; | ||
60 | import org.eclipse.rse.core.IRSECoreRegistry; | ||
61 | import org.eclipse.rse.core.subsystems.ISubSystem; | ||
62 | import org.eclipse.rse.core.subsystems.ISubSystemConfiguration; | ||
63 | import org.eclipse.rse.internal.core.RSEInitJob; | ||
64 | import org.eclipse.rse.internal.ui.view.SystemPerspectiveHelpers; | ||
65 | import org.eclipse.rse.services.IService; | ||
66 | import org.eclipse.rse.services.clientserver.messages.SystemMessageException; | ||
67 | import org.eclipse.rse.services.files.IFileService; | ||
68 | import org.eclipse.rse.services.files.IHostFile; | ||
69 | import org.eclipse.rse.services.shells.HostShellProcessAdapter; | ||
70 | import org.eclipse.rse.services.shells.IHostShell; | ||
71 | import org.eclipse.rse.services.shells.IShellService; | ||
72 | import org.eclipse.rse.subsystems.files.core.model.RemoteFileUtility; | ||
73 | import org.eclipse.rse.subsystems.files.core.servicesubsystem.FileServiceSubSystem; | ||
74 | import org.eclipse.rse.subsystems.files.core.servicesubsystem.IFileServiceSubSystem; | ||
75 | import org.eclipse.rse.subsystems.files.core.subsystems.IRemoteFileSubSystem; | ||
76 | import org.eclipse.rse.subsystems.shells.core.subsystems.servicesubsystem.IShellServiceSubSystem; | ||
77 | import org.eclipse.rse.subsystems.terminals.core.ITerminalServiceSubSystem; | ||
78 | import org.eclipse.rse.ui.RSEUIPlugin; | ||
79 | import org.eclipse.rse.ui.SystemBasePlugin; | ||
80 | import org.eclipse.rse.ui.SystemConnectionForm; | ||
81 | import org.eclipse.ui.console.MessageConsole; | ||
82 | |||
83 | public class RemoteHelper { | ||
84 | private final static String EXIT_CMD = "exit"; //$NON-NLS-1$ | ||
85 | private final static String CMD_DELIMITER = ";"; //$NON-NLS-1$ | ||
86 | private final static String LOCAL_CONN_NAME = "Local"; | ||
87 | private final static String CONNECTION_NAME = "127.0.0.1"; | ||
88 | private final static String HOST_NAME = "LOCALHOST"; | ||
89 | public static final String TERMINATOR = "234o987dsfkcqiuwey18837032843259d";//$NON-NLS-1$ | ||
90 | public static final int TOTALWORKLOAD = 100; | ||
91 | private static Map<IHost, RemoteMachine> machines; | ||
92 | |||
93 | public static IPath getWorkspaceMetaArea(){ | ||
94 | Workspace workspace = (Workspace)ResourcesPlugin.getWorkspace(); | ||
95 | LocalMetaArea metaDataArea = workspace.getMetaArea(); | ||
96 | return metaDataArea.getLocation(); | ||
97 | } | ||
98 | public static void storeProjDescrInMetaArea(IHost conn, String projName, String remoteSrc){ | ||
99 | IPath path = getWorkspaceMetaArea(); | ||
100 | String sep = File.separator; | ||
101 | String localDest = path.toString() + sep + ".projects" + sep + projName + sep + ".project"; | ||
102 | try { | ||
103 | getRemoteFile(conn, localDest, remoteSrc + sep + ".project", new NullProgressMonitor()); | ||
104 | } catch (Exception e) { | ||
105 | e.printStackTrace(); | ||
106 | } | ||
107 | } | ||
108 | public static String retrieveProjRootFromMetaArea(String projName){ | ||
109 | IPath path = getWorkspaceMetaArea(); | ||
110 | String sep = File.separator; | ||
111 | return path.toString() + sep + ".projects" + sep + projName + sep; | ||
112 | } | ||
113 | public static void storeURIInMetaArea(String projName, URI uri){ | ||
114 | IPath path = getWorkspaceMetaArea(); | ||
115 | String sep = File.separator; | ||
116 | File f = new File(path.toString() + sep + ".projects" + sep + projName + sep + ".originalURI"); | ||
117 | PrintWriter writer; | ||
118 | try { | ||
119 | writer = new PrintWriter(f); | ||
120 | writer.println(uri.getScheme()); | ||
121 | writer.println(uri.getHost()); | ||
122 | writer.println(uri.getPath()); | ||
123 | writer.println(uri.getFragment()); | ||
124 | writer.close(); | ||
125 | } catch (FileNotFoundException e) { | ||
126 | e.printStackTrace(); | ||
127 | } | ||
128 | } | ||
129 | |||
130 | public static URI retrieveURIFromMetaArea(String projName){ | ||
131 | IPath path = getWorkspaceMetaArea(); | ||
132 | String sep = File.separator; | ||
133 | File f = new File(path.toString() + sep + ".projects" + sep + projName + sep + ".originalURI"); | ||
134 | try { | ||
135 | BufferedReader buf = new BufferedReader(new FileReader(f)); | ||
136 | String line = null; | ||
137 | List<String> elems = new ArrayList<String>(); | ||
138 | while((line = buf.readLine()) != null){ | ||
139 | if (line.equals("null")) | ||
140 | line = null; | ||
141 | elems.add(line); | ||
142 | } | ||
143 | buf.close(); | ||
144 | if (elems.size() == 4){ | ||
145 | URI uri = new URI(elems.get(0), elems.get(1), elems.get(2), elems.get(3)); | ||
146 | return uri; | ||
147 | } | ||
148 | } catch (IOException e) { | ||
149 | e.printStackTrace(); | ||
150 | } catch (URISyntaxException e) { | ||
151 | e.printStackTrace(); | ||
152 | } | ||
153 | return null; | ||
154 | } | ||
155 | |||
156 | public static boolean isInitialized(final URI uri){ | ||
157 | boolean init = RSECorePlugin.isInitComplete(RSECorePlugin.INIT_MODEL); | ||
158 | if (!init) { | ||
159 | RSEInitJob.getInstance().addInitListener(new IRSEInitListener() { | ||
160 | @Override | ||
161 | public void phaseComplete(int arg0) { | ||
162 | try { | ||
163 | InternalFileSystemCore.getInstance().getStore(uri); | ||
164 | } catch (CoreException e) { | ||
165 | e.printStackTrace(); | ||
166 | } | ||
167 | } | ||
168 | }); | ||
169 | } | ||
170 | return init; | ||
171 | } | ||
172 | |||
173 | public static IHost getRemoteConnectionByName(String remoteConnection) { | ||
174 | if (remoteConnection == null) | ||
175 | return null; | ||
176 | IHost[] connections = RSECorePlugin.getTheSystemRegistry().getHosts(); | ||
177 | for (int i = 0; i < connections.length; i++) | ||
178 | if (connections[i].getAliasName().equals(remoteConnection)) | ||
179 | return connections[i]; | ||
180 | return null; | ||
181 | } | ||
182 | |||
183 | public static ISubSystem getFileSubsystem(IHost host) { | ||
184 | if (host == null) | ||
185 | return null; | ||
186 | ISubSystem[] subSystems = host.getSubSystems(); | ||
187 | for (int i = 0; i < subSystems.length; i++) { | ||
188 | if (subSystems[i] instanceof IFileServiceSubSystem) | ||
189 | return subSystems[i]; | ||
190 | } | ||
191 | return null; | ||
192 | } | ||
193 | |||
194 | public static ISubSystem getShellSubsystem(IHost host) { | ||
195 | if (host == null) | ||
196 | return null; | ||
197 | ISubSystem[] subSystems = host.getSubSystems(); | ||
198 | for (int i = 0; i < subSystems.length; i++) { | ||
199 | if (subSystems[i] instanceof IShellServiceSubSystem) | ||
200 | return subSystems[i]; | ||
201 | } | ||
202 | return null; | ||
203 | } | ||
204 | |||
205 | public static IHost[] getSuitableConnections() { | ||
206 | |||
207 | //we only get RSE connections with files&cmds subsystem | ||
208 | ArrayList <IHost> filConnections = new ArrayList <IHost>(Arrays.asList(RSECorePlugin.getTheSystemRegistry() | ||
209 | .getHostsBySubSystemConfigurationCategory(ISubSystemConfigurationCategories.SUBSYSTEM_CATEGORY_FILES))); //$NON-NLS-1$ | ||
210 | |||
211 | ArrayList <IHost> terminalConnections = new ArrayList <IHost>(Arrays.asList(RSECorePlugin.getTheSystemRegistry() | ||
212 | .getHostsBySubSystemConfigurationCategory("terminal")));//$NON-NLS-1$ | ||
213 | |||
214 | ArrayList <IHost> shellConnections = new ArrayList <IHost>(Arrays.asList(RSECorePlugin.getTheSystemRegistry() | ||
215 | .getHostsBySubSystemConfigurationCategory("shells"))); //$NON-NLS-1$ | ||
216 | |||
217 | Iterator <IHost>iter = filConnections.iterator(); | ||
218 | while(iter.hasNext()){ | ||
219 | IHost fileConnection = iter.next(); | ||
220 | if(!terminalConnections.contains(fileConnection) && !shellConnections.contains(fileConnection)){ | ||
221 | iter.remove(); | ||
222 | } | ||
223 | IRSESystemType sysType = fileConnection.getSystemType(); | ||
224 | if (sysType == null || !sysType.isEnabled()) { | ||
225 | iter.remove(); | ||
226 | } | ||
227 | } | ||
228 | |||
229 | return filConnections.toArray(new IHost[filConnections.size()]); | ||
230 | } | ||
231 | |||
232 | public static void putRemoteFileInPlugin(IHost connection, String locaPathInPlugin, String remoteExePath, | ||
233 | IProgressMonitor monitor) throws Exception { | ||
234 | |||
235 | assert(connection != null); | ||
236 | monitor.beginTask(Messages.InfoUpload, 100); | ||
237 | |||
238 | IFileService fileService; | ||
239 | try { | ||
240 | fileService = getConnectedRemoteFileService( | ||
241 | connection, | ||
242 | new SubProgressMonitor(monitor, 5)); | ||
243 | InputStream inputStream = FileLocator.openStream( | ||
244 | Activator.getDefault().getBundle(), new Path(locaPathInPlugin), false); | ||
245 | Path remotePath = new Path(remoteExePath); | ||
246 | |||
247 | //TODO workaround for now | ||
248 | //in case the underlying scp file service doesn't support inputStream upload | ||
249 | BufferedInputStream bis = new BufferedInputStream(inputStream); | ||
250 | File tempFile = File.createTempFile("scp", "temp"); //$NON-NLS-1$ //$NON-NLS-2$ | ||
251 | FileOutputStream os = new FileOutputStream(tempFile); | ||
252 | BufferedOutputStream bos = new BufferedOutputStream(os); | ||
253 | byte[] buffer = new byte[1024]; | ||
254 | int readCount; | ||
255 | while( (readCount = bis.read(buffer)) > 0) | ||
256 | { | ||
257 | bos.write(buffer, 0, readCount); | ||
258 | } | ||
259 | bos.close(); | ||
260 | fileService.upload(tempFile, remotePath.removeLastSegments(1) | ||
261 | .toString(), remotePath.lastSegment(), true, null, null, | ||
262 | new SubProgressMonitor(monitor, 80)); | ||
263 | // Need to change the permissions to match the original file | ||
264 | // permissions because of a bug in upload | ||
265 | remoteShellExec( | ||
266 | connection, | ||
267 | "", "chmod", "+x " + spaceEscapify(remotePath.toString()), new SubProgressMonitor(monitor, 5)); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ | ||
268 | |||
269 | } finally { | ||
270 | monitor.done(); | ||
271 | } | ||
272 | return; | ||
273 | } | ||
274 | |||
275 | public static void getRemoteFile(IHost connection, String localExePath, String remoteExePath, | ||
276 | IProgressMonitor monitor) throws Exception { | ||
277 | |||
278 | assert(connection!=null); | ||
279 | monitor.beginTask(Messages.InfoDownload, 100); | ||
280 | |||
281 | IFileService fileService; | ||
282 | try { | ||
283 | fileService = getConnectedRemoteFileService( | ||
284 | connection, | ||
285 | new SubProgressMonitor(monitor, 10)); | ||
286 | File file = new File(localExePath); | ||
287 | monitor.worked(5); | ||
288 | Path remotePath = new Path(remoteExePath); | ||
289 | fileService.download(remotePath.removeLastSegments(1).toString(), | ||
290 | remotePath.lastSegment(),file,true, null, | ||
291 | new SubProgressMonitor(monitor, 85)); | ||
292 | // Need to change the permissions to match the original file | ||
293 | // permissions because of a bug in upload | ||
294 | //RemoteApplication p = remoteShellExec( | ||
295 | // config, | ||
296 | // "", "chmod", "+x " + spaceEscapify(remotePath.toString()), new SubProgressMonitor(monitor, 5)); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ | ||
297 | //Thread.sleep(500); | ||
298 | //p.destroy(); | ||
299 | |||
300 | } finally { | ||
301 | monitor.done(); | ||
302 | } | ||
303 | return; | ||
304 | } | ||
305 | |||
306 | public static ITerminalServiceSubSystem getTerminalSubSystem( | ||
307 | IHost connection) { | ||
308 | ISystemRegistry systemRegistry = RSECorePlugin.getTheSystemRegistry(); | ||
309 | ISubSystem[] subsystems = systemRegistry.getSubSystems(connection); | ||
310 | for (int i = 0; i < subsystems.length; i++) { | ||
311 | if (subsystems[i] instanceof ITerminalServiceSubSystem) { | ||
312 | ITerminalServiceSubSystem subSystem = (ITerminalServiceSubSystem) subsystems[i]; | ||
313 | return subSystem; | ||
314 | } | ||
315 | } | ||
316 | return null; | ||
317 | } | ||
318 | |||
319 | public static String spaceEscapify(String inputString) { | ||
320 | if (inputString == null) | ||
321 | return null; | ||
322 | |||
323 | return inputString.replaceAll(" ", "\\\\ "); //$NON-NLS-1$ //$NON-NLS-2$ | ||
324 | } | ||
325 | |||
326 | public static Process remoteShellExec(IHost connection, | ||
327 | String prelaunchCmd, String remoteCommandPath, String arguments, | ||
328 | IProgressMonitor monitor) throws CoreException { | ||
329 | |||
330 | monitor.beginTask(NLS.bind(Messages.RemoteShellExec_1, | ||
331 | remoteCommandPath, arguments), 10); | ||
332 | String realRemoteCommand = arguments == null ? spaceEscapify(remoteCommandPath) | ||
333 | : spaceEscapify(remoteCommandPath) + " " + arguments; //$NON-NLS-1$ | ||
334 | |||
335 | String remoteCommand = realRemoteCommand + CMD_DELIMITER + EXIT_CMD; | ||
336 | |||
337 | if(prelaunchCmd != null) { | ||
338 | if (!prelaunchCmd.trim().equals("")) //$NON-NLS-1$ | ||
339 | remoteCommand = prelaunchCmd + CMD_DELIMITER + remoteCommand; | ||
340 | } | ||
341 | |||
342 | IShellService shellService; | ||
343 | Process p = null; | ||
344 | try { | ||
345 | shellService = (IShellService) getConnectedShellService( | ||
346 | connection, | ||
347 | new SubProgressMonitor(monitor, 7)); | ||
348 | |||
349 | // This is necessary because runCommand does not actually run the | ||
350 | // command right now. | ||
351 | String env[] = new String[0]; | ||
352 | try { | ||
353 | IHostShell hostShell = shellService.launchShell( | ||
354 | "", env, new SubProgressMonitor(monitor, 3)); //$NON-NLS-1$ | ||
355 | hostShell.writeToShell(remoteCommand); | ||
356 | p = new HostShellProcessAdapter(hostShell); | ||
357 | } catch (Exception e) { | ||
358 | if (p != null) { | ||
359 | p.destroy(); | ||
360 | } | ||
361 | abort(Messages.RemoteShellExec_2, e, | ||
362 | IRSECoreStatusCodes.EXCEPTION_OCCURRED); | ||
363 | } | ||
364 | } catch (Exception e1) { | ||
365 | abort(e1.getMessage(), e1, | ||
366 | IRSECoreStatusCodes.EXCEPTION_OCCURRED); | ||
367 | } | ||
368 | |||
369 | monitor.done(); | ||
370 | return p; | ||
371 | } | ||
372 | |||
373 | /** | ||
374 | * Throws a core exception with an error status object built from the given | ||
375 | * message, lower level exception, and error code. | ||
376 | * | ||
377 | * @param message | ||
378 | * the status message | ||
379 | * @param exception | ||
380 | * lower level exception associated with the error, or | ||
381 | * <code>null</code> if none | ||
382 | * @param code | ||
383 | * error code | ||
384 | */ | ||
385 | public static void abort(String message, Throwable exception, int code) throws CoreException { | ||
386 | IStatus status; | ||
387 | if (exception != null) { | ||
388 | MultiStatus multiStatus = new MultiStatus(Activator.PLUGIN_ID, code, message, exception); | ||
389 | multiStatus.add(new Status(IStatus.ERROR, Activator.PLUGIN_ID, code, exception.getLocalizedMessage(), exception)); | ||
390 | status = multiStatus; | ||
391 | } else { | ||
392 | status = new Status(IStatus.ERROR, Activator.PLUGIN_ID, code, message, null); | ||
393 | } | ||
394 | throw new CoreException(status); | ||
395 | } | ||
396 | /** | ||
397 | * Checks whether a IHost associated system's is enabled and not a local one | ||
398 | * @param host | ||
399 | * @return | ||
400 | */ | ||
401 | public static boolean isHostViable(IHost host) { | ||
402 | IRSESystemType sysType = host.getSystemType(); | ||
403 | if (sysType != null && sysType.isEnabled() && !sysType.isLocal()) | ||
404 | return true; | ||
405 | return false; | ||
406 | } | ||
407 | |||
408 | /** | ||
409 | * Ensures that RSECorePlugin is initialized before performing any actions | ||
410 | */ | ||
411 | public static void waitForRSEInitCompletition() { | ||
412 | if (!RSECorePlugin.isInitComplete(RSECorePlugin.INIT_MODEL)) | ||
413 | try { | ||
414 | RSECorePlugin.waitForInitCompletion(RSECorePlugin.INIT_MODEL); | ||
415 | } catch (InterruptedException e) { | ||
416 | return; | ||
417 | } | ||
418 | } | ||
419 | public static RemoteMachine getRemoteMachine(IHost connection){ | ||
420 | if (!getMachines().containsKey(connection)) | ||
421 | getMachines().put(connection, new RemoteMachine(connection)); | ||
422 | return getMachines().get(connection); | ||
423 | } | ||
424 | |||
425 | private static Map<IHost, RemoteMachine> getMachines() { | ||
426 | if (machines == null) | ||
427 | machines = new HashMap<IHost, RemoteMachine>(); | ||
428 | return machines; | ||
429 | } | ||
430 | |||
431 | public static MessageConsole getConsole(IHost connection) { | ||
432 | return getRemoteMachine(connection).getConsole(); | ||
433 | } | ||
434 | |||
435 | public static CommandResponseHandler getCommandHandler(IHost connection) { | ||
436 | return getRemoteMachine(connection).getCmdHandler(); | ||
437 | } | ||
438 | |||
439 | public static ProcessStreamBuffer processOutput(IProgressMonitor monitor, IHostShell hostShell, CommandResponseHandler cmdHandler) throws Exception { | ||
440 | return new CommandOutputProcessor(monitor, hostShell, cmdHandler, "").processOutput(); | ||
441 | } | ||
442 | |||
443 | public static IHost getRemoteConnectionForURI(URI uri, IProgressMonitor monitor) { | ||
444 | if (uri == null) | ||
445 | return null; | ||
446 | |||
447 | String host = uri.getHost(); | ||
448 | if (host == null) { | ||
449 | // this is a local connection | ||
450 | ISystemRegistry sr = RSECorePlugin.getTheSystemRegistry(); | ||
451 | IHost local = null; | ||
452 | while (local == null) { | ||
453 | local = sr.getLocalHost(); | ||
454 | } | ||
455 | return local; | ||
456 | } | ||
457 | ISystemRegistry sr = RSECorePlugin.getTheSystemRegistry(); | ||
458 | IHost[] connections = sr.getHosts(); | ||
459 | |||
460 | IHost unconnected = null; | ||
461 | for (IHost conn : connections) { | ||
462 | if (host.equalsIgnoreCase(conn.getHostName())) { | ||
463 | IRemoteFileSubSystem fss = getRemoteFileSubSystem(conn); | ||
464 | if (fss != null && fss.isConnected()) | ||
465 | return conn; | ||
466 | unconnected = conn; | ||
467 | } | ||
468 | } | ||
469 | |||
470 | return unconnected; | ||
471 | } | ||
472 | |||
473 | public static IRemoteFileSubSystem getRemoteFileSubSystem(IHost host) { | ||
474 | IRemoteFileSubSystem candidate = null; | ||
475 | IRemoteFileSubSystem otherServiceCandidate = null; | ||
476 | IRemoteFileSubSystem[] subSystems = RemoteFileUtility.getFileSubSystems(host); | ||
477 | |||
478 | for (IRemoteFileSubSystem subSystem : subSystems) { | ||
479 | if (subSystem instanceof FileServiceSubSystem) { | ||
480 | if (subSystem.isConnected()) | ||
481 | return subSystem; | ||
482 | |||
483 | if (otherServiceCandidate == null) | ||
484 | otherServiceCandidate = subSystem; | ||
485 | |||
486 | } else if (candidate == null || (subSystem.isConnected() && !candidate.isConnected())) | ||
487 | candidate = subSystem; | ||
488 | |||
489 | } | ||
490 | if (candidate != null && candidate.isConnected()) | ||
491 | return candidate; | ||
492 | if (otherServiceCandidate != null) | ||
493 | return otherServiceCandidate; | ||
494 | return null; | ||
495 | } | ||
496 | |||
497 | public static IFileService getConnectedRemoteFileService(IHost connection, IProgressMonitor monitor) throws Exception { | ||
498 | return getRemoteMachine(connection).getRemoteFileService(monitor); | ||
499 | } | ||
500 | |||
501 | public static IHostFile[] getRemoteDirContent(IHost connection, String remoteParent, String fileFilter, int fileType, IProgressMonitor monitor){ | ||
502 | |||
503 | try { | ||
504 | IFileService fileServ = getConnectedRemoteFileService(connection, monitor); | ||
505 | return fileServ.list(remoteParent, fileFilter, fileType, monitor); | ||
506 | } catch (SystemMessageException e) { | ||
507 | e.printStackTrace(); | ||
508 | } catch (Exception e) { | ||
509 | e.printStackTrace(); | ||
510 | } | ||
511 | return null; | ||
512 | } | ||
513 | |||
514 | public static IService getConnectedShellService(IHost connection, IProgressMonitor monitor) throws Exception { | ||
515 | return getRemoteMachine(connection).getShellService(monitor); | ||
516 | } | ||
517 | |||
518 | public static void handleRunCommandRemote(IHost connection, YoctoCommand cmd, IProgressMonitor monitor){ | ||
519 | try { | ||
520 | CommandRunnable cmdRun = new CommandRunnable(connection, cmd, monitor); | ||
521 | cmdRun.run(); | ||
522 | } catch (Exception e) { | ||
523 | e.printStackTrace(); | ||
524 | } | ||
525 | } | ||
526 | |||
527 | public static IHostShell runCommandRemote(IHost connection, YoctoCommand cmd, | ||
528 | IProgressMonitor monitor) throws CoreException { | ||
529 | |||
530 | monitor.beginTask(NLS.bind(Messages.RemoteShellExec_1, | ||
531 | cmd, cmd.getArguments()), 10); | ||
532 | |||
533 | String remoteCommand = cmd.getCommand() + " " + cmd.getArguments() + " ; echo " + TERMINATOR + "; exit ;"; | ||
534 | |||
535 | IShellService shellService; | ||
536 | try { | ||
537 | shellService = (IShellService) getConnectedShellService(connection, new SubProgressMonitor(monitor, 7)); | ||
538 | |||
539 | String env[] = getRemoteMachine(connection).prepareEnvString(monitor); | ||
540 | |||
541 | try { | ||
542 | IHostShell hostShell = shellService.runCommand(cmd.getInitialDirectory(), remoteCommand, env, new SubProgressMonitor(monitor, 3)); | ||
543 | return hostShell; | ||
544 | } catch (Exception e) { | ||
545 | e.printStackTrace(); | ||
546 | } | ||
547 | } catch (Exception e1) { | ||
548 | e1.printStackTrace(); | ||
549 | } | ||
550 | return null; | ||
551 | } | ||
552 | |||
553 | public static IHostFile getRemoteHostFile(IHost connection, String remoteFilePath, IProgressMonitor monitor){ | ||
554 | assert(connection != null); | ||
555 | monitor.beginTask(Messages.InfoDownload, 100); | ||
556 | |||
557 | try { | ||
558 | IFileService fileService = getConnectedRemoteFileService(connection, new SubProgressMonitor(monitor, 10)); | ||
559 | Path remotePath = new Path(remoteFilePath); | ||
560 | IHostFile remoteFile = fileService.getFile(remotePath.removeLastSegments(1).toString(), remotePath.lastSegment(), new SubProgressMonitor(monitor, 5)); | ||
561 | return remoteFile; | ||
562 | } catch (Exception e) { | ||
563 | e.printStackTrace(); | ||
564 | }finally { | ||
565 | monitor.done(); | ||
566 | } | ||
567 | return null; | ||
568 | } | ||
569 | |||
570 | public static InputStream getRemoteInputStream(IHost connection, String parentPath, String remoteFilePath, IProgressMonitor monitor){ | ||
571 | assert(connection != null); | ||
572 | monitor.beginTask(Messages.InfoDownload, 100); | ||
573 | |||
574 | try { | ||
575 | IFileService fileService = getConnectedRemoteFileService(connection, new SubProgressMonitor(monitor, 10)); | ||
576 | |||
577 | return fileService.getInputStream(parentPath, remoteFilePath, false, monitor); | ||
578 | } catch (Exception e) { | ||
579 | e.printStackTrace(); | ||
580 | }finally { | ||
581 | monitor.done(); | ||
582 | } | ||
583 | return null; | ||
584 | } | ||
585 | |||
586 | public static URI createNewURI(URI oldURI, String name) { | ||
587 | try { | ||
588 | String sep = oldURI.getPath().endsWith("/") ? "" : "/"; | ||
589 | return new URI(oldURI.getScheme(), oldURI.getHost(), oldURI.getPath() + sep + name, oldURI.getFragment()); | ||
590 | } catch (URISyntaxException e) { | ||
591 | e.printStackTrace(); | ||
592 | return null; | ||
593 | } | ||
594 | } | ||
595 | |||
596 | public static boolean fileExistsRemote(IHost conn, IProgressMonitor monitor, String path) { | ||
597 | try { | ||
598 | IFileService fs = getConnectedRemoteFileService(conn, monitor); | ||
599 | int nameStart = path.lastIndexOf("/"); | ||
600 | String parentPath = path.substring(0, nameStart); | ||
601 | String name = path.substring(nameStart + 1); | ||
602 | IHostFile hostFile = fs.getFile(parentPath, name, monitor); | ||
603 | |||
604 | return hostFile.exists(); | ||
605 | } catch (Exception e) { | ||
606 | e.printStackTrace(); | ||
607 | } | ||
608 | return false; | ||
609 | } | ||
610 | |||
611 | public static IHost createLocalConnection() { | ||
612 | IHost createdHost = null; | ||
613 | try { | ||
614 | |||
615 | ISubSystemConfigurator[] configurators = getSubSystemConfigurators(); | ||
616 | |||
617 | IRSESystemType systemType = getSSHSystemType(); | ||
618 | ISystemRegistry sr = RSECorePlugin.getTheSystemRegistry(); | ||
619 | IHost[] connections = sr.getHosts(); | ||
620 | for (IHost conn : connections) { | ||
621 | if (conn.getName().equals(LOCAL_CONN_NAME)) { | ||
622 | ISystemHostPool pool = conn.getHostPool(); | ||
623 | createdHost = sr.createHost(pool.getSystemProfile().getName(), systemType, CONNECTION_NAME, HOST_NAME, "", "",IRSEUserIdConstants.USERID_LOCATION_NOTSET,configurators); | ||
624 | break; | ||
625 | } | ||
626 | } | ||
627 | |||
628 | // a tweak that is the result of UCD feedback. Phil | ||
629 | if ((createdHost != null) && SystemPerspectiveHelpers.isRSEPerspectiveActive()) { | ||
630 | if (systemType.getId().equals(IRSESystemType.SYSTEMTYPE_ISERIES_ID)) { | ||
631 | ISubSystem[] objSubSystems = sr.getSubSystemsBySubSystemConfigurationCategory("nativefiles", createdHost); //$NON-NLS-1$ | ||
632 | if ((objSubSystems != null) && (objSubSystems.length > 0))// might be in product that doesn't have iSeries plugins | ||
633 | RSEUIPlugin.getTheSystemRegistryUI().expandSubSystem(objSubSystems[0]); | ||
634 | else | ||
635 | RSEUIPlugin.getTheSystemRegistryUI().expandHost(createdHost); | ||
636 | } else | ||
637 | RSEUIPlugin.getTheSystemRegistryUI().expandHost(createdHost); | ||
638 | } | ||
639 | } catch (Exception exc) { | ||
640 | exc.printStackTrace(); | ||
641 | } | ||
642 | return createdHost; | ||
643 | } | ||
644 | |||
645 | private static IRSESystemType getSSHSystemType() { | ||
646 | IRSECoreRegistry coreReg = RSECorePlugin.getTheCoreRegistry(); | ||
647 | return coreReg.getSystemTypeById("org.eclipse.rse.systemtype.ssh"); | ||
648 | } | ||
649 | |||
650 | private static ISubSystemConfigurator[] getSubSystemConfigurators() | ||
651 | { | ||
652 | // what kind of subsystems do we have here? | ||
653 | ISystemRegistry sr = RSECorePlugin.getTheSystemRegistry(); | ||
654 | ISubSystemConfiguration[] configurations = sr.getSubSystemConfigurationsBySystemType(getSSHSystemType(), true); | ||
655 | |||
656 | ArrayList configList = new ArrayList(); | ||
657 | for (int i = 0; i < configurations.length; i++){ | ||
658 | ISubSystemConfiguration configuration = configurations[i]; | ||
659 | |||
660 | class DefaultConfigurator implements ISubSystemConfigurator { | ||
661 | private ISubSystemConfiguration _configuration; | ||
662 | public DefaultConfigurator(ISubSystemConfiguration configuration){ | ||
663 | _configuration = configuration; | ||
664 | } | ||
665 | |||
666 | public boolean applyValues(ISubSystem ss) { | ||
667 | return true; | ||
668 | } | ||
669 | |||
670 | public ISubSystemConfiguration getSubSystemConfiguration() { | ||
671 | return _configuration; | ||
672 | } | ||
673 | } | ||
674 | configList.add(new DefaultConfigurator(configuration)); | ||
675 | } | ||
676 | |||
677 | return (ISubSystemConfigurator[])configList.toArray(new ISubSystemConfigurator[configList.size()]); | ||
678 | |||
679 | } | ||
680 | } | ||
diff --git a/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/RemoteMachine.java b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/RemoteMachine.java new file mode 100644 index 0000000..92cfc15 --- /dev/null +++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/RemoteMachine.java | |||
@@ -0,0 +1,202 @@ | |||
1 | /******************************************************************************* | ||
2 | * Copyright (c) 2013 Intel Corporation. | ||
3 | * All rights reserved. This program and the accompanying materials | ||
4 | * are made available under the terms of the Eclipse Public License v1.0 | ||
5 | * which accompanies this distribution, and is available at | ||
6 | * http://www.eclipse.org/legal/epl-v10.html | ||
7 | * | ||
8 | * Contributors: | ||
9 | * Ioana Grigoropol(Intel) - initial API and implementation | ||
10 | *******************************************************************************/ | ||
11 | package org.yocto.remote.utils; | ||
12 | |||
13 | import java.util.ArrayList; | ||
14 | import java.util.HashMap; | ||
15 | import java.util.List; | ||
16 | import java.util.Map; | ||
17 | |||
18 | import org.eclipse.core.runtime.CoreException; | ||
19 | import org.eclipse.core.runtime.IProgressMonitor; | ||
20 | import org.eclipse.core.runtime.NullProgressMonitor; | ||
21 | import org.eclipse.core.runtime.OperationCanceledException; | ||
22 | import org.eclipse.core.runtime.Status; | ||
23 | import org.eclipse.core.runtime.SubProgressMonitor; | ||
24 | import org.eclipse.rse.core.model.IHost; | ||
25 | import org.eclipse.rse.core.subsystems.ISubSystem; | ||
26 | import org.eclipse.rse.internal.services.local.shells.LocalShellService; | ||
27 | import org.eclipse.rse.services.clientserver.messages.SystemMessageException; | ||
28 | import org.eclipse.rse.services.files.IFileService; | ||
29 | import org.eclipse.rse.services.shells.IHostShell; | ||
30 | import org.eclipse.rse.services.shells.IShellService; | ||
31 | import org.eclipse.rse.subsystems.files.core.servicesubsystem.IFileServiceSubSystem; | ||
32 | import org.eclipse.rse.subsystems.shells.core.subsystems.servicesubsystem.IShellServiceSubSystem; | ||
33 | import org.eclipse.ui.console.MessageConsole; | ||
34 | |||
35 | public class RemoteMachine { | ||
36 | public static final String PROXY = "proxy"; | ||
37 | |||
38 | private Map<String, String> environment; | ||
39 | private MessageConsole console; | ||
40 | private CommandResponseHandler cmdHandler; | ||
41 | private IShellService shellService; | ||
42 | private IHost connection; | ||
43 | |||
44 | private ISubSystem fileSubSystem; | ||
45 | private IFileService fileService; | ||
46 | |||
47 | public RemoteMachine(IHost connection) { | ||
48 | setConnection(connection); | ||
49 | } | ||
50 | |||
51 | public String[] prepareEnvString(IProgressMonitor monitor){ | ||
52 | String[] env = null; | ||
53 | try { | ||
54 | if (shellService instanceof LocalShellService) { | ||
55 | env = shellService.getHostEnvironment(); | ||
56 | } else { | ||
57 | List<String> envList = new ArrayList<String>(); | ||
58 | getRemoteEnvProxyVars(monitor); | ||
59 | String value = ""; | ||
60 | for (String varName : environment.keySet()){ | ||
61 | value = varName + "=" + environment.get(varName); | ||
62 | envList.add(value); | ||
63 | } | ||
64 | env = envList.toArray(new String[envList.size()]); | ||
65 | } | ||
66 | } catch (Exception e) { | ||
67 | e.printStackTrace(); | ||
68 | } | ||
69 | |||
70 | return env; | ||
71 | } | ||
72 | public void getRemoteEnvProxyVars(IProgressMonitor monitor){ | ||
73 | try { | ||
74 | if (environment != null && !environment.isEmpty()) | ||
75 | return; | ||
76 | |||
77 | environment = new HashMap<String, String>(); | ||
78 | |||
79 | IShellService shellService = getShellService(new SubProgressMonitor(monitor, 7)); | ||
80 | |||
81 | ProcessStreamBuffer buffer = null; | ||
82 | try { | ||
83 | SubProgressMonitor subMonitor = new SubProgressMonitor(monitor, 3); | ||
84 | IHostShell hostShell = shellService.runCommand("", "env" + " ; echo " + RemoteHelper.TERMINATOR + "; exit;", new String[]{}, subMonitor); | ||
85 | buffer = RemoteHelper.processOutput(subMonitor, hostShell, cmdHandler); | ||
86 | for(int i = 0; i < buffer.getOutputLines().size(); i++) { | ||
87 | String out = buffer.getOutputLines().get(i); | ||
88 | String[] tokens = out.split("="); | ||
89 | if (tokens.length != 2) | ||
90 | continue; | ||
91 | String varName = tokens[0]; | ||
92 | String varValue = tokens[1]; | ||
93 | if (varName.contains(PROXY)) | ||
94 | environment.put(varName, varValue); | ||
95 | } | ||
96 | } catch (Exception e) { | ||
97 | e.printStackTrace(); | ||
98 | } | ||
99 | |||
100 | } catch (Exception e) { | ||
101 | e.printStackTrace(); | ||
102 | } | ||
103 | } | ||
104 | |||
105 | public Map<String, String> getEnvironment() { | ||
106 | return environment; | ||
107 | } | ||
108 | public void setEnvironment(Map<String, String> environment) { | ||
109 | this.environment = environment; | ||
110 | } | ||
111 | public MessageConsole getConsole() { | ||
112 | if (console == null) | ||
113 | console = ConsoleHelper.findConsole(ConsoleHelper.YOCTO_CONSOLE); | ||
114 | |||
115 | ConsoleHelper.showConsole(console); | ||
116 | return console; | ||
117 | } | ||
118 | public CommandResponseHandler getCmdHandler() { | ||
119 | if (cmdHandler == null) | ||
120 | cmdHandler = new CommandResponseHandler(getConsole()); | ||
121 | return cmdHandler; | ||
122 | } | ||
123 | |||
124 | public IShellService getShellService(IProgressMonitor monitor) throws Exception { | ||
125 | if (shellService != null) | ||
126 | return shellService; | ||
127 | |||
128 | final ISubSystem subsystem = getShellSubsystem(); | ||
129 | |||
130 | if (subsystem == null) | ||
131 | throw new Exception(Messages.ErrorNoSubsystem); | ||
132 | |||
133 | try { | ||
134 | subsystem.connect(monitor, false); | ||
135 | } catch (CoreException e) { | ||
136 | throw e; | ||
137 | } catch (OperationCanceledException e) { | ||
138 | throw new CoreException(Status.CANCEL_STATUS); | ||
139 | } | ||
140 | |||
141 | if (!subsystem.isConnected()) | ||
142 | throw new Exception(Messages.ErrorConnectSubsystem); | ||
143 | |||
144 | shellService = ((IShellServiceSubSystem) subsystem).getShellService(); | ||
145 | return shellService; | ||
146 | } | ||
147 | |||
148 | private ISubSystem getShellSubsystem() { | ||
149 | if (connection == null) | ||
150 | return null; | ||
151 | ISubSystem[] subSystems = connection.getSubSystems(); | ||
152 | for (int i = 0; i < subSystems.length; i++) { | ||
153 | if (subSystems[i] instanceof IShellServiceSubSystem) | ||
154 | return subSystems[i]; | ||
155 | } | ||
156 | return null; | ||
157 | } | ||
158 | |||
159 | public IHost getConnection() { | ||
160 | return connection; | ||
161 | } | ||
162 | public void setConnection(IHost connection) { | ||
163 | this.connection = connection; | ||
164 | } | ||
165 | |||
166 | public IFileService getRemoteFileService(IProgressMonitor monitor) throws Exception { | ||
167 | if (fileService == null) { | ||
168 | |||
169 | while(getFileSubsystem() == null) | ||
170 | Thread.sleep(2); | ||
171 | try { | ||
172 | getFileSubsystem().connect(monitor, false); | ||
173 | } catch (CoreException e) { | ||
174 | throw e; | ||
175 | } catch (OperationCanceledException e) { | ||
176 | throw new CoreException(Status.CANCEL_STATUS); | ||
177 | } | ||
178 | |||
179 | if (!getFileSubsystem().isConnected()) | ||
180 | throw new Exception(Messages.ErrorConnectSubsystem); | ||
181 | |||
182 | fileService = ((IFileServiceSubSystem) getFileSubsystem()).getFileService(); | ||
183 | } | ||
184 | return fileService; | ||
185 | } | ||
186 | |||
187 | public ISubSystem getFileSubsystem() { | ||
188 | if (fileSubSystem == null) { | ||
189 | if (connection == null) | ||
190 | return null; | ||
191 | ISubSystem[] subSystems = connection.getSubSystems(); | ||
192 | for (int i = 0; i < subSystems.length; i++) { | ||
193 | if (subSystems[i] instanceof IFileServiceSubSystem) { | ||
194 | fileSubSystem = subSystems[i]; | ||
195 | break; | ||
196 | } | ||
197 | } | ||
198 | } | ||
199 | return fileSubSystem; | ||
200 | } | ||
201 | |||
202 | } | ||
diff --git a/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/RemoteShellExec.java b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/RemoteShellExec.java new file mode 100644 index 0000000..711088c --- /dev/null +++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/RemoteShellExec.java | |||
@@ -0,0 +1,140 @@ | |||
1 | /******************************************************************************* | ||
2 | * Copyright (c) 2013 Intel Corporation. | ||
3 | * All rights reserved. This program and the accompanying materials | ||
4 | * are made available under the terms of the Eclipse Public License v1.0 | ||
5 | * which accompanies this distribution, and is available at | ||
6 | * http://www.eclipse.org/legal/epl-v10.html | ||
7 | * | ||
8 | * Contributors: | ||
9 | * Intel - initial API and implementation | ||
10 | *******************************************************************************/ | ||
11 | package org.yocto.remote.utils; | ||
12 | |||
13 | import java.io.BufferedReader; | ||
14 | import java.io.IOException; | ||
15 | import java.io.InputStream; | ||
16 | import java.io.InputStreamReader; | ||
17 | import java.io.OutputStream; | ||
18 | |||
19 | import org.eclipse.core.runtime.IProgressMonitor; | ||
20 | import org.eclipse.rse.core.model.IHost; | ||
21 | |||
22 | public class RemoteShellExec { | ||
23 | |||
24 | public static final int | ||
25 | STATE_NULL = 0, | ||
26 | STATE_RUNNING = 1, | ||
27 | STATE_EXITED = 2; | ||
28 | |||
29 | private final String command; | ||
30 | private final IHost host; | ||
31 | |||
32 | private InputStream fInStream; | ||
33 | private OutputStream fOutStream; | ||
34 | private InputStream fErrStream; | ||
35 | private Process remoteShellProcess; | ||
36 | |||
37 | private int exitCode = 0; | ||
38 | private int status = STATE_NULL; | ||
39 | |||
40 | private final String RETURN_VALUE_TAG = "org.yocto.sdk.remotetools.RVTAG"; | ||
41 | private final String RETURN_VALUE_CMD = ";echo \"" + RETURN_VALUE_TAG + "$?\""; | ||
42 | |||
43 | public RemoteShellExec(IHost host, String command) { | ||
44 | assert(host != null); | ||
45 | this.host = host; | ||
46 | this.command = command; | ||
47 | } | ||
48 | |||
49 | public int getStatus() { | ||
50 | return status; | ||
51 | } | ||
52 | |||
53 | public int getExitCode() { | ||
54 | return exitCode; | ||
55 | } | ||
56 | |||
57 | private void reset() { | ||
58 | fInStream = null; | ||
59 | fOutStream = null; | ||
60 | fErrStream = null; | ||
61 | |||
62 | remoteShellProcess = null; | ||
63 | exitCode = 0; | ||
64 | status = STATE_NULL; | ||
65 | } | ||
66 | |||
67 | public InputStream getInputStream() { | ||
68 | return fInStream; | ||
69 | } | ||
70 | |||
71 | public OutputStream getOutputStream() { | ||
72 | return fOutStream; | ||
73 | } | ||
74 | |||
75 | public InputStream getErrStream() { | ||
76 | return fErrStream; | ||
77 | } | ||
78 | |||
79 | public synchronized void start(String prelaunchCmd, String argument, IProgressMonitor monitor) throws Exception { | ||
80 | if(status == STATE_RUNNING) | ||
81 | return; | ||
82 | |||
83 | reset(); | ||
84 | argument = (argument == null ? RETURN_VALUE_CMD : argument + RETURN_VALUE_CMD); | ||
85 | remoteShellProcess = RemoteHelper.remoteShellExec(this.host, prelaunchCmd, this.command, argument, monitor); | ||
86 | fInStream = remoteShellProcess.getInputStream(); | ||
87 | fOutStream = remoteShellProcess.getOutputStream(); | ||
88 | fErrStream = remoteShellProcess.getErrorStream(); | ||
89 | status = STATE_RUNNING; | ||
90 | } | ||
91 | |||
92 | public synchronized void terminate() throws Exception { | ||
93 | if(status != STATE_RUNNING || remoteShellProcess != null) | ||
94 | return; | ||
95 | |||
96 | remoteShellProcess.destroy(); | ||
97 | reset(); | ||
98 | } | ||
99 | |||
100 | public int waitFor(IProgressMonitor monitor) throws InterruptedException { | ||
101 | while(status == STATE_RUNNING) { | ||
102 | if(monitor != null) { | ||
103 | if(monitor.isCanceled()) { | ||
104 | throw new InterruptedException("User Cancelled"); | ||
105 | } | ||
106 | } | ||
107 | |||
108 | try { | ||
109 | remoteShellProcess.waitFor(); | ||
110 | }catch(InterruptedException e){ | ||
111 | //get the return value | ||
112 | try { | ||
113 | if(fInStream.available() != 0) { | ||
114 | BufferedReader in = new BufferedReader(new InputStreamReader(fInStream)); | ||
115 | String thisline; | ||
116 | int idx; | ||
117 | while((thisline = in.readLine()) != null) { | ||
118 | if(thisline.indexOf(RETURN_VALUE_CMD) == -1) { | ||
119 | idx = thisline.indexOf(RETURN_VALUE_TAG); | ||
120 | if(idx != -1) { | ||
121 | try { | ||
122 | exitCode=(new Integer(thisline.substring(idx+RETURN_VALUE_TAG.length()))).intValue(); | ||
123 | }catch(NumberFormatException e2) { | ||
124 | } | ||
125 | break; | ||
126 | } | ||
127 | } | ||
128 | } | ||
129 | } | ||
130 | }catch(IOException e1) { | ||
131 | //do nothing | ||
132 | } | ||
133 | }finally { | ||
134 | status=STATE_EXITED; | ||
135 | } | ||
136 | } | ||
137 | return exitCode; | ||
138 | } | ||
139 | } | ||
140 | |||
diff --git a/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/ShellSession.java b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/ShellSession.java new file mode 100644 index 0000000..0922824 --- /dev/null +++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/ShellSession.java | |||
@@ -0,0 +1,332 @@ | |||
1 | /***************************************************************************** | ||
2 | * Copyright (c) 2013 Ken Gilmer | ||
3 | * All rights reserved. This program and the accompanying materials | ||
4 | * are made available under the terms of the Eclipse Public License v1.0 | ||
5 | * which accompanies this distribution, and is available at | ||
6 | * http://www.eclipse.org/legal/epl-v10.html | ||
7 | * | ||
8 | * Contributors: | ||
9 | * Ken Gilmer - initial API and implementation | ||
10 | * Jessica Zhang - Adopt for Yocto Tools plugin | ||
11 | *******************************************************************************/ | ||
12 | package org.yocto.remote.utils; | ||
13 | |||
14 | import java.io.BufferedReader; | ||
15 | import java.io.File; | ||
16 | import java.io.IOException; | ||
17 | import java.io.InputStream; | ||
18 | import java.io.InputStreamReader; | ||
19 | import java.io.OutputStream; | ||
20 | import java.io.OutputStreamWriter; | ||
21 | import java.lang.reflect.InvocationTargetException; | ||
22 | import java.util.regex.Matcher; | ||
23 | import java.util.regex.Pattern; | ||
24 | |||
25 | import org.eclipse.swt.widgets.Display; | ||
26 | |||
27 | public class ShellSession { | ||
28 | /** | ||
29 | * Bash shell | ||
30 | */ | ||
31 | public static final int SHELL_TYPE_BASH = 1; | ||
32 | /** | ||
33 | * sh shell | ||
34 | */ | ||
35 | public static final int SHELL_TYPE_SH = 2; | ||
36 | private volatile boolean interrupt = false; | ||
37 | /** | ||
38 | * String used to isolate command execution | ||
39 | */ | ||
40 | public static final String TERMINATOR = "build$"; | ||
41 | public static final String LT = System.getProperty("line.separator"); | ||
42 | private Process process; | ||
43 | |||
44 | private OutputStream pos = null; | ||
45 | |||
46 | private String shellPath = null; | ||
47 | private final String initCmd; | ||
48 | private final File root; | ||
49 | private final File builddir; | ||
50 | |||
51 | private OutputStreamWriter out; | ||
52 | |||
53 | public static String getFilePath(String file) throws IOException { | ||
54 | File f = new File(file); | ||
55 | |||
56 | if (!f.exists() || f.isDirectory()) { | ||
57 | throw new IOException("Path passed is not a file: " + file); | ||
58 | } | ||
59 | |||
60 | StringBuffer sb = new StringBuffer(); | ||
61 | |||
62 | String elems[] = file.split(File.separator); | ||
63 | |||
64 | for (int i = 0; i < elems.length - 1; ++i) { | ||
65 | sb.append(elems[i]); | ||
66 | sb.append(File.separator); | ||
67 | } | ||
68 | |||
69 | return sb.toString(); | ||
70 | } | ||
71 | |||
72 | public ShellSession(int shellType, File root, File builddir, String initCmd, OutputStream out) throws IOException { | ||
73 | this.root = root; | ||
74 | this.builddir = builddir; | ||
75 | this.initCmd = initCmd; | ||
76 | if (out == null) { | ||
77 | this.out = new OutputStreamWriter(null); | ||
78 | } else { | ||
79 | this.out = new OutputStreamWriter(out); | ||
80 | } | ||
81 | if (shellType == SHELL_TYPE_SH) { | ||
82 | shellPath = "/bin/sh"; | ||
83 | } | ||
84 | shellPath = "/bin/bash"; | ||
85 | |||
86 | initializeShell(); | ||
87 | } | ||
88 | |||
89 | private void initializeShell() throws IOException { | ||
90 | process = Runtime.getRuntime().exec(shellPath); | ||
91 | pos = process.getOutputStream(); | ||
92 | |||
93 | if (root != null) { | ||
94 | execute("cd " + root.getAbsolutePath()); | ||
95 | } | ||
96 | |||
97 | if (initCmd != null) { | ||
98 | execute("source " + initCmd + " " + builddir.getAbsolutePath()); | ||
99 | } | ||
100 | } | ||
101 | |||
102 | synchronized | ||
103 | public String execute(String command, int[] retCode) throws IOException { | ||
104 | String errorMessage = null; | ||
105 | |||
106 | interrupt = false; | ||
107 | out.write(command); | ||
108 | out.write(LT); | ||
109 | |||
110 | sendToProcessAndTerminate(command); | ||
111 | |||
112 | if (process.getErrorStream().available() > 0) { | ||
113 | byte[] msg = new byte[process.getErrorStream().available()]; | ||
114 | |||
115 | process.getErrorStream().read(msg, 0, msg.length); | ||
116 | String msg_str = new String(msg); | ||
117 | out.write(msg_str); | ||
118 | out.write(LT); | ||
119 | if (!msg_str.contains("WARNING")) | ||
120 | errorMessage = "Error while executing: " + command + LT + new String(msg); | ||
121 | } | ||
122 | |||
123 | BufferedReader br = new BufferedReader(new InputStreamReader(process | ||
124 | .getInputStream())); | ||
125 | |||
126 | StringBuffer sb = new StringBuffer(); | ||
127 | String line = null; | ||
128 | |||
129 | while (true) { | ||
130 | line = br.readLine(); | ||
131 | if (line != null) { | ||
132 | sb.append(line); | ||
133 | sb.append(LT); | ||
134 | out.write(line); | ||
135 | out.write(LT); | ||
136 | } | ||
137 | if (line.endsWith(TERMINATOR)) | ||
138 | break; | ||
139 | } | ||
140 | if (interrupt) { | ||
141 | process.destroy(); | ||
142 | initializeShell(); | ||
143 | interrupt = false; | ||
144 | }else if (line != null && retCode != null) { | ||
145 | try { | ||
146 | retCode[0]=Integer.parseInt(line.substring(0,line.lastIndexOf(TERMINATOR))); | ||
147 | }catch (NumberFormatException e) { | ||
148 | throw new IOException("Can NOT get return code" + command + LT + line); | ||
149 | } | ||
150 | } | ||
151 | out.flush(); | ||
152 | if (errorMessage != null) { | ||
153 | throw new IOException(errorMessage); | ||
154 | } | ||
155 | return sb.toString(); | ||
156 | } | ||
157 | |||
158 | synchronized | ||
159 | public void execute(String command) throws IOException { | ||
160 | interrupt = false; | ||
161 | String errorMessage = null; | ||
162 | |||
163 | sendToProcessAndTerminate(command); | ||
164 | boolean cancel = false; | ||
165 | try { | ||
166 | InputStream is = process.getInputStream(); | ||
167 | InputStream es = process.getErrorStream(); | ||
168 | String info; | ||
169 | while (!cancel) { | ||
170 | info = null; | ||
171 | StringBuffer buffer = new StringBuffer(); | ||
172 | int c; | ||
173 | while (is.available() > 0) { | ||
174 | c = is.read(); | ||
175 | char ch = (char) c; | ||
176 | buffer.append(ch); | ||
177 | if (ch == '\n') { | ||
178 | info = buffer.toString(); | ||
179 | if (!info.trim().endsWith(TERMINATOR)) { | ||
180 | out.write(info); | ||
181 | out.write(LT); | ||
182 | buffer.delete(0, buffer.length()); | ||
183 | } else { | ||
184 | cancel = true; | ||
185 | break; | ||
186 | } | ||
187 | } | ||
188 | } | ||
189 | while (es.available() > 0) { | ||
190 | c = es.read(); | ||
191 | char ch = (char) c; | ||
192 | buffer.append(ch); | ||
193 | if (ch == '\n') { | ||
194 | info = buffer.toString(); | ||
195 | if (!info.contains("WARNING")) | ||
196 | errorMessage += info; | ||
197 | out.write(info); | ||
198 | out.write(LT); | ||
199 | buffer.delete(0, buffer.length()); | ||
200 | } | ||
201 | } | ||
202 | } | ||
203 | } catch (IOException e) { | ||
204 | try { | ||
205 | throw new InvocationTargetException(e); | ||
206 | } catch (InvocationTargetException e1) { | ||
207 | e1.printStackTrace(); | ||
208 | } | ||
209 | } | ||
210 | out.flush(); | ||
211 | if (errorMessage != null) { | ||
212 | throw new IOException(errorMessage); | ||
213 | } | ||
214 | if (interrupt) { | ||
215 | process.destroy(); | ||
216 | initializeShell(); | ||
217 | interrupt = false; | ||
218 | } | ||
219 | } | ||
220 | synchronized | ||
221 | public boolean ensureKnownHostKey(String user, String host) throws IOException { | ||
222 | |||
223 | boolean loadKeysMatch = false; | ||
224 | boolean accepted = false; | ||
225 | Process proc = Runtime.getRuntime().exec("ssh -o LogLevel=DEBUG3 " + user + "@" + host); | ||
226 | Pattern patternLoad = Pattern.compile("^debug3: load_hostkeys: loaded (\\d+) keys"); | ||
227 | Pattern patternAuthSucceeded = Pattern.compile("^debug1: Authentication succeeded.*"); | ||
228 | |||
229 | try { | ||
230 | InputStream es = proc.getErrorStream(); | ||
231 | String info; | ||
232 | while (!loadKeysMatch) { | ||
233 | info = null; | ||
234 | StringBuffer buffer = new StringBuffer(); | ||
235 | int c; | ||
236 | while (es.available() > 0) { | ||
237 | c = es.read(); | ||
238 | char ch = (char) c; | ||
239 | buffer.append(ch); | ||
240 | if (ch == '\r') { | ||
241 | info = buffer.toString().trim(); | ||
242 | Matcher m = patternLoad.matcher(info); | ||
243 | if(m.matches()) { | ||
244 | int keys = new Integer(m.group(1)); | ||
245 | if (keys == 0) { | ||
246 | proc.destroy(); | ||
247 | DialogRunnable runnable = new DialogRunnable("Host authenticity", "The authenticity of host '" + host + "(" + host + ")' can't be established.\nAre you sure you want to continue connecting ?", DialogRunnable.QUESTION); | ||
248 | Display.getDefault().syncExec(runnable); | ||
249 | accepted = runnable.result; | ||
250 | if (accepted){ | ||
251 | proc = Runtime.getRuntime().exec("ssh -o StrictHostKeyChecking=no " + user + "@" + host);//add host key to known_hosts | ||
252 | try { | ||
253 | Thread.sleep(2000); //wait for process to finish | ||
254 | } catch (InterruptedException e) { | ||
255 | e.printStackTrace(); | ||
256 | } | ||
257 | proc.destroy(); | ||
258 | } else { | ||
259 | Display.getDefault().syncExec( new DialogRunnable("Host authenticity", "Host key verification failed.", DialogRunnable.ERROR)); | ||
260 | } | ||
261 | } else { | ||
262 | String errorMsg = ""; | ||
263 | // wait to check if key is the same and authentication succeeds | ||
264 | while (es.available() > 0) { | ||
265 | c = es.read(); | ||
266 | ch = (char) c; | ||
267 | buffer.append(ch); | ||
268 | if (ch == '\r') { | ||
269 | info = buffer.toString().trim(); | ||
270 | Matcher mAuthS = patternAuthSucceeded.matcher(info); | ||
271 | if(mAuthS.matches()) { | ||
272 | accepted = true; | ||
273 | break; | ||
274 | } else { | ||
275 | if (!info.startsWith("debug")) | ||
276 | errorMsg += info + "\n"; | ||
277 | } | ||
278 | try { | ||
279 | Thread.sleep(100); | ||
280 | } catch (InterruptedException e) { | ||
281 | // TODO Auto-generated catch block | ||
282 | e.printStackTrace(); | ||
283 | } | ||
284 | buffer.delete(0, buffer.length()); | ||
285 | } | ||
286 | } | ||
287 | if (!accepted && !errorMsg.isEmpty()) { | ||
288 | Display.getDefault().syncExec( new DialogRunnable("Host authenticity", errorMsg, DialogRunnable.ERROR)); | ||
289 | } | ||
290 | } | ||
291 | loadKeysMatch = true; | ||
292 | break; | ||
293 | } | ||
294 | buffer.delete(0, buffer.length()); | ||
295 | } | ||
296 | } | ||
297 | } | ||
298 | es.close(); | ||
299 | } catch (IOException e) { | ||
300 | try { | ||
301 | throw new InvocationTargetException(e); | ||
302 | } catch (InvocationTargetException e1) { | ||
303 | e1.printStackTrace(); | ||
304 | } | ||
305 | } | ||
306 | return accepted; | ||
307 | } | ||
308 | |||
309 | /** | ||
310 | * Send command string to shell process and add special terminator string so | ||
311 | * reader knows when output is complete. | ||
312 | * | ||
313 | * @param command | ||
314 | * @throws IOException | ||
315 | */ | ||
316 | private void sendToProcessAndTerminate(String command) throws IOException { | ||
317 | pos.write(command.getBytes()); | ||
318 | pos.write(LT.getBytes()); | ||
319 | pos.flush(); | ||
320 | pos.write("echo $?".getBytes()); | ||
321 | pos.write(TERMINATOR.getBytes()); | ||
322 | pos.write(LT.getBytes()); | ||
323 | pos.flush(); | ||
324 | } | ||
325 | |||
326 | /** | ||
327 | * Interrupt any running processes. | ||
328 | */ | ||
329 | public void interrupt() { | ||
330 | interrupt = true; | ||
331 | } | ||
332 | } | ||
diff --git a/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/TerminalHandler.java b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/TerminalHandler.java new file mode 100644 index 0000000..af5a5da --- /dev/null +++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/TerminalHandler.java | |||
@@ -0,0 +1,132 @@ | |||
1 | /******************************************************************************* | ||
2 | * Copyright (c) 2013 Intel Corporation. | ||
3 | * All rights reserved. This program and the accompanying materials | ||
4 | * are made available under the terms of the Eclipse Public License v1.0 | ||
5 | * which accompanies this distribution, and is available at | ||
6 | * http://www.eclipse.org/legal/epl-v10.html | ||
7 | * | ||
8 | * Contributors: | ||
9 | * Intel - initial API and implementation | ||
10 | *******************************************************************************/ | ||
11 | package org.yocto.remote.utils; | ||
12 | |||
13 | import org.eclipse.core.commands.AbstractHandler; | ||
14 | import org.eclipse.core.commands.ExecutionException; | ||
15 | import org.eclipse.core.runtime.IProgressMonitor; | ||
16 | import org.eclipse.core.runtime.NullProgressMonitor; | ||
17 | import org.eclipse.core.runtime.OperationCanceledException; | ||
18 | import org.eclipse.jface.dialogs.ProgressMonitorDialog; | ||
19 | import org.eclipse.jface.operation.IRunnableWithProgress; | ||
20 | import org.eclipse.rse.core.model.IHost; | ||
21 | import org.eclipse.rse.internal.terminals.ui.TerminalServiceHelper; | ||
22 | import org.eclipse.rse.internal.terminals.ui.views.RSETerminalConnector; | ||
23 | import org.eclipse.rse.internal.terminals.ui.views.TerminalViewTab; | ||
24 | import org.eclipse.rse.internal.terminals.ui.views.TerminalViewer; | ||
25 | import org.eclipse.rse.internal.terminals.ui.views.TerminalsUI; | ||
26 | import org.eclipse.rse.services.terminals.ITerminalShell; | ||
27 | import org.eclipse.rse.subsystems.terminals.core.ITerminalServiceSubSystem; | ||
28 | import org.eclipse.rse.subsystems.terminals.core.elements.TerminalElement; | ||
29 | import org.eclipse.rse.ui.SystemBasePlugin; | ||
30 | import org.eclipse.swt.custom.CTabItem; | ||
31 | import org.eclipse.swt.events.DisposeEvent; | ||
32 | import org.eclipse.swt.events.DisposeListener; | ||
33 | import org.eclipse.swt.widgets.Shell; | ||
34 | import org.eclipse.tm.internal.terminal.control.ITerminalViewControl; | ||
35 | import org.eclipse.tm.internal.terminal.provisional.api.ITerminalConnector; | ||
36 | |||
37 | abstract public class TerminalHandler extends AbstractHandler { | ||
38 | |||
39 | |||
40 | protected Shell shell; | ||
41 | |||
42 | protected String changeTerm = "export TERM=vt100;"; | ||
43 | |||
44 | abstract protected String getInitCmd(); | ||
45 | abstract protected String getConnnectionName(); | ||
46 | abstract protected String getDialogTitle(); | ||
47 | |||
48 | protected String changeTerm() { | ||
49 | return changeTerm; | ||
50 | } | ||
51 | |||
52 | protected ITerminalShell getTerminalShellFromTab(CTabItem item) { | ||
53 | ITerminalShell terminalShell = null; | ||
54 | ITerminalViewControl terminalViewControl = (ITerminalViewControl) item | ||
55 | .getData(TerminalViewTab.DATA_KEY_CONTROL); | ||
56 | ITerminalConnector terminalConnector = terminalViewControl | ||
57 | .getTerminalConnector(); | ||
58 | if (terminalConnector instanceof RSETerminalConnector) { | ||
59 | RSETerminalConnector rseTerminalConnector = (RSETerminalConnector) terminalConnector; | ||
60 | terminalShell = rseTerminalConnector.getTerminalHostShell(); | ||
61 | } | ||
62 | return terminalShell; | ||
63 | } | ||
64 | |||
65 | protected boolean preProcess(final ITerminalServiceSubSystem terminalSubSystem) { | ||
66 | if (!terminalSubSystem.isConnected()) { | ||
67 | try { | ||
68 | ProgressMonitorDialog dialog = new ProgressMonitorDialog(shell); | ||
69 | dialog.run(true, true, new IRunnableWithProgress(){ | ||
70 | @Override | ||
71 | public void run(IProgressMonitor monitor) { | ||
72 | monitor.beginTask("Connecting to remote target ...", 100); | ||
73 | try { | ||
74 | terminalSubSystem.connect(new NullProgressMonitor(), false); | ||
75 | monitor.done(); | ||
76 | } catch (Exception e) { | ||
77 | CommonHelper.showErrorDialog("Connection failure", null, e.getMessage()); | ||
78 | monitor.done(); | ||
79 | |||
80 | } | ||
81 | } | ||
82 | }); | ||
83 | } catch (OperationCanceledException e) { | ||
84 | // user canceled, return silently | ||
85 | return false; | ||
86 | } catch (Exception e) { | ||
87 | SystemBasePlugin.logError(e.getLocalizedMessage(), e); | ||
88 | return false; | ||
89 | } | ||
90 | } else | ||
91 | return true; | ||
92 | return false; | ||
93 | } | ||
94 | |||
95 | public void execute(IHost host) throws ExecutionException { | ||
96 | |||
97 | final ITerminalServiceSubSystem terminalSubSystem = RemoteHelper.getTerminalSubSystem(host); | ||
98 | |||
99 | if (terminalSubSystem != null) { | ||
100 | TerminalsUI terminalsUI = TerminalsUI.getInstance(); | ||
101 | TerminalViewer viewer = terminalsUI.activateTerminalsView(); | ||
102 | if (preProcess(terminalSubSystem)) { | ||
103 | CTabItem tab = viewer.getTabFolder().createTabItem( | ||
104 | terminalSubSystem.getHost(), changeTerm() + getInitCmd()); | ||
105 | //since RSETerminalConnector not exit the shell during the diconnection, | ||
106 | //we have manually exit it here | ||
107 | try { | ||
108 | tab.addDisposeListener(new DisposeListener() { | ||
109 | @Override | ||
110 | public void widgetDisposed(DisposeEvent e) { | ||
111 | Object source = e.getSource(); | ||
112 | if (source instanceof CTabItem) { | ||
113 | CTabItem currentItem = (CTabItem) source; | ||
114 | ITerminalShell shell=getTerminalShellFromTab(currentItem); | ||
115 | if(shell!=null) { | ||
116 | shell.exit(); | ||
117 | } | ||
118 | } | ||
119 | } | ||
120 | }); | ||
121 | }catch(Exception e) { | ||
122 | e.printStackTrace(); | ||
123 | } | ||
124 | TerminalElement element = TerminalServiceHelper | ||
125 | .createTerminalElement(tab, terminalSubSystem); | ||
126 | terminalSubSystem.addChild(element); | ||
127 | |||
128 | } | ||
129 | } | ||
130 | } | ||
131 | |||
132 | } | ||
diff --git a/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/YoctoCommand.java b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/YoctoCommand.java new file mode 100644 index 0000000..23292d8 --- /dev/null +++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/YoctoCommand.java | |||
@@ -0,0 +1,63 @@ | |||
1 | /******************************************************************************* | ||
2 | * Copyright (c) 2013 Intel Corporation. | ||
3 | * All rights reserved. This program and the accompanying materials | ||
4 | * are made available under the terms of the Eclipse Public License v1.0 | ||
5 | * which accompanies this distribution, and is available at | ||
6 | * http://www.eclipse.org/legal/epl-v10.html | ||
7 | * | ||
8 | * Contributors: | ||
9 | * Ioana Grigoropol(Intel) - initial API and implementation | ||
10 | *******************************************************************************/ | ||
11 | package org.yocto.remote.utils; | ||
12 | |||
13 | |||
14 | public class YoctoCommand { | ||
15 | private String command; | ||
16 | private String initialDirectory; | ||
17 | private String arguments; | ||
18 | private ProcessStreamBuffer processBuffer; | ||
19 | |||
20 | public YoctoCommand(String command, String initialDirectory, String arguments){ | ||
21 | this.setCommand(command); | ||
22 | this.setInitialDirectory(initialDirectory); | ||
23 | this.setArguments(arguments); | ||
24 | this.setProcessBuffer(new ProcessStreamBuffer(false)); | ||
25 | } | ||
26 | |||
27 | public String getCommand() { | ||
28 | return command; | ||
29 | } | ||
30 | |||
31 | public void setCommand(String command) { | ||
32 | this.command = "bash -l -c \"" + command + "\""; | ||
33 | } | ||
34 | |||
35 | public String getInitialDirectory() { | ||
36 | return initialDirectory; | ||
37 | } | ||
38 | |||
39 | public void setInitialDirectory(String initialDirectory) { | ||
40 | this.initialDirectory = initialDirectory; | ||
41 | } | ||
42 | |||
43 | public String getArguments() { | ||
44 | return arguments; | ||
45 | } | ||
46 | |||
47 | public void setArguments(String arguments) { | ||
48 | this.arguments = arguments; | ||
49 | } | ||
50 | |||
51 | public ProcessStreamBuffer getProcessBuffer() { | ||
52 | return processBuffer; | ||
53 | } | ||
54 | |||
55 | public void setProcessBuffer(ProcessStreamBuffer processBuffer) { | ||
56 | this.processBuffer = processBuffer; | ||
57 | } | ||
58 | |||
59 | @Override | ||
60 | public String toString() { | ||
61 | return command + " " + arguments; | ||
62 | } | ||
63 | } | ||