[yocto] [Refactor RFC 2/9] Add remote tools classes needed for bitbake remote capabilities
Grigoropol, IoanaX
ioanax.grigoropol at intel.com
Fri Jun 7 08:29:40 PDT 2013
Hi Jessica,
I have sent you a set of 8 patches that replaces the second patch (2/9). I have added the new classes incrementally and put the changes to the RemoteHelper along with the classes that are strongly linked with it.
I have also sent a pull request for the whole set of patches(50). They can be found also on poky-contrib: igrigorx/common-remote-refactor.
Thanks,
Ioana
________________________________________
From: Zhang, Jessica
Sent: Friday, June 07, 2013 2:53 AM
To: Grigoropol, IoanaX; yocto at yoctoproject.org
Subject: RE: [yocto] [Refactor RFC 2/9] Add remote tools classes needed for bitbake remote capabilities
Hi Ioana,
Please separate this into 2 patches, one is for adding those new util files and also please add License for them. Then make the RemoteHelper.java into a separate patch. Other comments are:
1.please add much more detailed information in your patch to explain why we need new util classes and why RemoteHelper.java need to be changed.
2. there're many new functions that using IHost variable and you don't need to check for IHost is null case?
Thanks
Jessica
-----Original Message-----
From: yocto-bounces at yoctoproject.org [mailto:yocto-bounces at yoctoproject.org] On Behalf Of Ioana Grigoropol
Sent: Tuesday, June 04, 2013 6:26 AM
To: yocto at yoctoproject.org
Subject: [yocto] [Refactor RFC 2/9] Add remote tools classes needed for bitbake remote capabilities
Signed-off-by: Ioana Grigoropol <ioanax.grigoropol at intel.com>
---
.../org.yocto.remote.utils/META-INF/MANIFEST.MF | 8 +-
.../yocto/remote/utils/CommandOutputProcessor.java | 33 +++
.../yocto/remote/utils/CommandResponseHandler.java | 36 +++
.../org/yocto/remote/utils/CommandRunnable.java | 34 +++
.../src/org/yocto/remote/utils/ConsoleHelper.java | 28 +++
.../org/yocto/remote/utils/ConsoleRunnable.java | 37 +++
.../remote/utils/ICommandResponseHandler.java | 15 ++
.../org/yocto/remote/utils/OutputProcessor.java | 102 ++++++++
.../yocto/remote/utils/ProcessStreamBuffer.java | 77 ++++++
.../src/org/yocto/remote/utils/RemoteHelper.java | 255 ++++++++++++++++----
.../src/org/yocto/remote/utils/RemoteMachine.java | 206 ++++++++++++++++
.../src/org/yocto/remote/utils/Session.java | 117 +++++++++
.../src/org/yocto/remote/utils/YoctoCommand.java | 53 ++++
13 files changed, 952 insertions(+), 49 deletions(-) create mode 100644 plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/CommandOutputProcessor.java
create mode 100644 plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/CommandResponseHandler.java
create mode 100644 plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/CommandRunnable.java
create mode 100644 plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/ConsoleHelper.java
create mode 100644 plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/ConsoleRunnable.java
create mode 100644 plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/ICommandResponseHandler.java
create mode 100644 plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/OutputProcessor.java
create mode 100644 plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/ProcessStreamBuffer.java
create mode 100644 plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/RemoteMachine.java
create mode 100644 plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/Session.java
create mode 100644 plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/YoctoCommand.java
diff --git a/plugins/org.yocto.remote.utils/META-INF/MANIFEST.MF b/plugins/org.yocto.remote.utils/META-INF/MANIFEST.MF
index c7b57fe..06d14f8 100644
--- a/plugins/org.yocto.remote.utils/META-INF/MANIFEST.MF
+++ b/plugins/org.yocto.remote.utils/META-INF/MANIFEST.MF
@@ -11,17 +11,23 @@ Bundle-RequiredExecutionEnvironment: JavaSE-1.6
Import-Package: org.eclipse.rse.core,
org.eclipse.rse.core.model,
org.eclipse.rse.core.subsystems,
+ org.eclipse.rse.internal.services.local.shells,
+ org.eclipse.rse.internal.services.shells,
org.eclipse.rse.internal.terminals.ui,
org.eclipse.rse.internal.terminals.ui.views,
org.eclipse.rse.services,
+ org.eclipse.rse.services.clientserver.messages,
org.eclipse.rse.services.files,
org.eclipse.rse.services.shells,
org.eclipse.rse.services.terminals,
+ org.eclipse.rse.subsystems.files.core.model,
org.eclipse.rse.subsystems.files.core.servicesubsystem,
+ org.eclipse.rse.subsystems.files.core.subsystems,
org.eclipse.rse.subsystems.shells.core.subsystems.servicesubsystem,
org.eclipse.rse.subsystems.terminals.core,
org.eclipse.rse.subsystems.terminals.core.elements,
org.eclipse.rse.ui,
org.eclipse.tm.internal.terminal.control,
- org.eclipse.tm.internal.terminal.provisional.api
+ org.eclipse.tm.internal.terminal.provisional.api,
+ org.eclipse.ui.console
Export-Package: org.yocto.remote.utils
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..4fca662
--- /dev/null
+++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/CommandO
+++ utputProcessor.java
@@ -0,0 +1,33 @@
+package org.yocto.remote.utils;
+
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.rse.services.shells.IHostShell;
+
+public class CommandOutputProcessor extends OutputProcessor {
+
+ public CommandOutputProcessor(IProgressMonitor monitor,
+ IHostShell hostShell, CommandResponseHandler cmdHandler, String task) {
+ super(monitor, hostShell, cmdHandler, task);
+ }
+
+ @Override
+ protected boolean isErrChStop(char ch) {
+ return (ch == '\n');
+ }
+
+ @Override
+ protected boolean isOutChStop(char ch) {
+ return (ch == '\n');
+ }
+
+ @Override
+ protected void processOutputBufferLine(char ch, String str) {
+ processBuffer.addOutputLine(str);
+ }
+
+ @Override
+ protected void processErrorBufferLine(char ch, String str) {
+ processBuffer.addErrorLine(str);
+ }
+
+}
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..0785c45
--- /dev/null
+++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/CommandR
+++ esponseHandler.java
@@ -0,0 +1,36 @@
+package org.yocto.remote.utils;
+
+import org.eclipse.ui.console.MessageConsole;
+import org.eclipse.ui.console.MessageConsoleStream;
+
+public class CommandResponseHandler implements ICommandResponseHandler {
+ private MessageConsoleStream consoleStream;
+ private Boolean errorOccured = false;
+
+ public CommandResponseHandler(MessageConsole console) {
+ try {
+ this.consoleStream = console.newMessageStream();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ public Boolean hasError() {
+ return errorOccured;
+ }
+
+ @Override
+ public void response(String line, boolean isError) {
+ try {
+ if (isError) {
+ consoleStream.println(line);
+ errorOccured = true;
+ } else {
+ consoleStream.println(line);
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+}
\ 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..46a3f35
--- /dev/null
+++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/CommandR
+++ unnable.java
@@ -0,0 +1,34 @@
+package org.yocto.remote.utils;
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.rse.core.model.IHost; import
+org.eclipse.rse.services.shells.IHostShell;
+
+public class CommandRunnable implements Runnable{
+ private IHostShell hostShell;
+ private final IHost connection;
+ private final YoctoCommand cmd;
+ private final IProgressMonitor monitor;
+ private final CommandResponseHandler cmdHandler;
+
+ CommandRunnable(IHost connection, YoctoCommand cmd, IProgressMonitor monitor){
+ this.connection = connection;
+ this.cmdHandler = RemoteHelper.getCommandHandler(connection);
+ this.cmd = cmd;
+ this.monitor = monitor;
+ this.hostShell = null;
+ }
+ @Override
+ public void run() {
+ try {
+ hostShell = RemoteHelper.runCommandRemote(connection, cmd, monitor);
+ cmd.setProcessBuffer(RemoteHelper.processOutput(monitor, hostShell, cmdHandler));
+ } catch (CoreException e) {
+ e.printStackTrace();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+}
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..307e219
--- /dev/null
+++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/ConsoleH
+++ elper.java
@@ -0,0 +1,28 @@
+package org.yocto.remote.utils;
+
+import org.eclipse.swt.widgets.Display; import
+org.eclipse.ui.console.ConsolePlugin;
+import org.eclipse.ui.console.IConsole; import
+org.eclipse.ui.console.IConsoleManager;
+import org.eclipse.ui.console.MessageConsole;
+
+public class ConsoleHelper {
+ public static final String YOCTO_CONSOLE = "Yocto Project Console";
+
+ public static MessageConsole findConsole(String name) {
+ ConsolePlugin plugin = ConsolePlugin.getDefault();
+ IConsoleManager conMan = plugin.getConsoleManager();
+ IConsole[] existing = conMan.getConsoles();
+ for (int i = 0; i < existing.length; i++)
+ if (name.equals(existing[i].getName()))
+ return (MessageConsole) existing[i];
+ // no console found, so create a new one
+ MessageConsole myConsole = new MessageConsole(name, null);
+ conMan.addConsoles(new IConsole[] { myConsole });
+ return myConsole;
+ }
+
+ public static void showConsole(MessageConsole console){
+ Display.getDefault().syncExec(new ConsoleRunnable(console));
+ }
+}
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..f3b0ccd
--- /dev/null
+++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/ConsoleR
+++ unnable.java
@@ -0,0 +1,37 @@
+package org.yocto.remote.utils;
+
+import org.eclipse.ui.IWorkbench;
+import org.eclipse.ui.IWorkbenchPage;
+import org.eclipse.ui.IWorkbenchWindow; import
+org.eclipse.ui.PlatformUI; import
+org.eclipse.ui.console.IConsoleConstants;
+import org.eclipse.ui.console.IConsoleView;
+import org.eclipse.ui.console.MessageConsole;
+
+public class ConsoleRunnable implements Runnable{
+ MessageConsole console;
+ ConsoleRunnable (MessageConsole console){
+ this.console = console;
+ }
+ @Override
+ public void run() {
+ IWorkbench wb = PlatformUI.getWorkbench();
+ if (wb == null)
+ return;
+ IWorkbenchWindow win = wb.getActiveWorkbenchWindow();
+ if (win == null)
+ return;
+ IWorkbenchPage page = win.getActivePage();
+ if (page == null)
+ return;
+ String id = IConsoleConstants.ID_CONSOLE_VIEW;
+ try {
+ IConsoleView view = (IConsoleView) page.showView(id);
+ if (view == null)
+ return;
+ view.display(console);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+}
\ 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..a8a8f95
--- /dev/null
+++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/ICommand
+++ ResponseHandler.java
@@ -0,0 +1,15 @@
+/**********************************************************************
+*******
+ * Copyright (c) 2009 Ken Gilmer
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License
+v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Ken Gilmer - initial API and implementation
+
+***********************************************************************
+********/
+package org.yocto.remote.utils;
+
+public interface ICommandResponseHandler {
+ public void response(String line, boolean isError); }
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..a06f077
--- /dev/null
+++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/OutputPr
+++ ocessor.java
@@ -0,0 +1,102 @@
+package org.yocto.remote.utils;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.concurrent.locks.Lock;
+
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.rse.internal.services.local.shells.LocalHostShell;
+import
+org.eclipse.rse.internal.services.shells.TerminalServiceHostShell;
+import org.eclipse.rse.services.shells.HostShellProcessAdapter;
+import org.eclipse.rse.services.shells.IHostShell;
+
+public abstract class OutputProcessor{
+ private static final int ERROR_BUFFER = 1;
+ private static final int OUTPUT_BUFFER = 2;
+ protected String task;
+ protected ProcessStreamBuffer processBuffer;
+ protected IHostShell hostShell;
+ protected CommandResponseHandler cmdHandler;
+ protected IProgressMonitor monitor;
+
+ public OutputProcessor(IProgressMonitor monitor, IHostShell hostShell, CommandResponseHandler cmdHandler, String task){
+ this.monitor = monitor;
+ this.hostShell = hostShell;
+ this.processBuffer = new ProcessStreamBuffer(hostShell instanceof TerminalServiceHostShell);
+ this.cmdHandler = cmdHandler;
+ this.task = task;
+ }
+ public ProcessStreamBuffer processOutput() throws Exception{
+ if (hostShell == null)
+ throw new Exception("An error has occured while trying to run remote command!");
+ monitor.beginTask(this.task, RemoteHelper.TOTALWORKLOAD);
+ Lock lock = null;
+ if (hostShell instanceof LocalHostShell) {
+ lock = ((LocalHostShell)hostShell).getLock();
+ lock.lock();
+ }
+ BufferedReader inbr = null;
+ BufferedReader errbr = null;
+
+ if (hostShell instanceof LocalHostShell) {
+ inbr = ((LocalHostShell)hostShell).getReader(false);
+ errbr = ((LocalHostShell)hostShell).getReader(true);
+ } else {
+ Process p = new HostShellProcessAdapter(hostShell);
+ inbr = new BufferedReader(new InputStreamReader(p.getInputStream()));
+ errbr = new BufferedReader(new InputStreamReader(p.getErrorStream()));
+ }
+ boolean cancel = false;
+ while (!cancel) {
+ if(monitor.isCanceled()) {
+ cancel = true;
+ if (lock != null)
+ lock.unlock();
+ throw new InterruptedException("User Cancelled");
+ }
+ processBuffer(errbr, ERROR_BUFFER);
+ processBuffer(inbr, OUTPUT_BUFFER);
+ cancel = true;
+ }
+ if (lock != null)
+ lock.unlock();
+ return processBuffer;
+ }
+ protected abstract boolean isErrChStop(char ch);
+ protected abstract boolean isOutChStop(char ch);
+ protected boolean isChStop(char ch, int type){
+ if (type == ERROR_BUFFER)
+ return isErrChStop(ch);
+ else if(type == OUTPUT_BUFFER)
+ return isOutChStop(ch);
+ return false;
+ }
+ protected abstract void processOutputBufferLine(char ch, String str);
+ protected abstract void processErrorBufferLine(char ch, String str);
+ protected void processBufferLine(String str, char ch, int type){
+ if (type == ERROR_BUFFER)
+ processErrorBufferLine(ch, str);
+ else if(type == OUTPUT_BUFFER)
+ processOutputBufferLine(ch, str);
+ }
+ protected void processBuffer(BufferedReader br, int type) throws IOException{
+ StringBuffer buffer = new StringBuffer();
+ int c;
+ if (br != null)
+ while ((c = br.read()) != -1) {
+ char ch = (char) c;
+ buffer.append(ch);
+ if (isChStop(ch, type)){
+ String str = buffer.toString();
+ processBufferLine(str, ch, type);
+ System.out.println(str);
+ if (str.trim().equals(RemoteHelper.TERMINATOR)) {
+ break;
+ }
+ cmdHandler.response(str, false);
+ buffer.delete(0, buffer.length());
+ }
+ }
+ }
+}
\ 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..3fe8731
--- /dev/null
+++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/ProcessS
+++ treamBuffer.java
@@ -0,0 +1,77 @@
+package org.yocto.remote.utils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+public class ProcessStreamBuffer {
+ private static final String WHITESPACES = "\\s+";
+ List<String> errorLines;
+ List<String> outputLines;
+ boolean isTerminal;
+
+ ProcessStreamBuffer(boolean isTerminal){
+ this.isTerminal = isTerminal;
+ errorLines = new ArrayList<String>();
+ outputLines = new ArrayList<String>();
+ }
+
+ public void addErrorLine(String line){
+ errorLines.add(line);
+ }
+ public void addOutputLine(String line){
+ outputLines.add(line);
+ }
+
+ public List<String> getOutputLines(){
+ return outputLines;
+ }
+
+ public List<String> getErrorLines(){
+ return errorLines;
+ }
+
+ public String getMergedOutputLines(){
+ String returnVal = "";
+ for (int i = 0; i < outputLines.size(); i++) {
+ String line = outputLines.get(i);
+ returnVal += line;
+ if (outputLines.size() > 1 && i != outputLines.size() - 1)
+ returnVal += "\n";
+ }
+ return returnVal;
+ }
+
+ public boolean hasErrors() {
+ return errorLines.size() != 0;
+ }
+
+ public String getLastOutputLineContaining(String str) {
+ if (!errorLines.isEmpty())
+ return null;
+ for (int i = outputLines.size() - 1; i >= 0; i--){
+ String line = outputLines.get(i);
+ if (line.replaceAll(WHITESPACES, "").contains(str.replaceAll(WHITESPACES, "")))
+ return line;
+ }
+ return null;
+ }
+
+ public String getOutputLineContaining(String arg, String pattern) {
+ List<String> lines = null;
+ if (isTerminal)
+ lines = errorLines;
+ else
+ lines = outputLines;
+ for (int i = lines.size() - 1; i >= 0; i--){
+ String line = lines.get(i);
+ if (line.contains(arg)) {
+ String[] tokens = line.split("\\s+");
+ if (Pattern.matches(pattern, tokens[0])) {
+ return tokens[0];
+ }
+ }
+ }
+ return "";
+ }
+}
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
index a1e9a08..e9118d6 100644
--- a/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/RemoteHelper.java
+++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/RemoteHe
+++ lper.java
@@ -16,16 +16,19 @@ import java.io.BufferedOutputStream; import java.io.File; import java.io.FileOutputStream; import java.io.InputStream;
+import java.net.URI;
+import java.net.URISyntaxException;
import java.util.ArrayList;
import java.util.Arrays;
+import java.util.HashMap;
import java.util.Iterator;
+import java.util.Map;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.FileLocator;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.IStatus; import org.eclipse.core.runtime.MultiStatus;
-import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Status; import org.eclipse.core.runtime.SubProgressMonitor;
@@ -38,17 +41,26 @@ import org.eclipse.rse.core.model.ISubSystemConfigurationCategories;
import org.eclipse.rse.core.model.ISystemRegistry;
import org.eclipse.rse.core.subsystems.ISubSystem;
import org.eclipse.rse.services.IService;
+import
+org.eclipse.rse.services.clientserver.messages.SystemMessageException;
import org.eclipse.rse.services.files.IFileService;
+import org.eclipse.rse.services.files.IHostFile;
import org.eclipse.rse.services.shells.HostShellProcessAdapter;
import org.eclipse.rse.services.shells.IHostShell;
import org.eclipse.rse.services.shells.IShellService;
+import org.eclipse.rse.subsystems.files.core.model.RemoteFileUtility;
+import
+org.eclipse.rse.subsystems.files.core.servicesubsystem.FileServiceSubSy
+stem;
import org.eclipse.rse.subsystems.files.core.servicesubsystem.IFileServiceSubSystem;
+import
+org.eclipse.rse.subsystems.files.core.subsystems.IRemoteFileSubSystem;
import org.eclipse.rse.subsystems.shells.core.subsystems.servicesubsystem.IShellServiceSubSystem;
import org.eclipse.rse.subsystems.terminals.core.ITerminalServiceSubSystem;
+import org.eclipse.ui.console.MessageConsole;
public class RemoteHelper {
private final static String EXIT_CMD = "exit"; //$NON-NLS-1$
private final static String CMD_DELIMITER = ";"; //$NON-NLS-1$
+ public static final String TERMINATOR = "234o987dsfkcqiuwey18837032843259d";//$NON-NLS-1$
+ public static final int TOTALWORKLOAD = 100;
+ private static Map<IHost, RemoteMachine> machines;
public static IHost getRemoteConnectionByName(String remoteConnection) {
if (remoteConnection == null)
@@ -57,30 +69,7 @@ public class RemoteHelper {
for (int i = 0; i < connections.length; i++)
if (connections[i].getAliasName().equals(remoteConnection))
return connections[i];
- return null; // TODO Connection is not found in the list--need to react
- // somehow, throw the exception?
-
- }
-
- public static IService getConnectedRemoteFileService(
- IHost currentConnection, IProgressMonitor monitor) throws Exception {
- final ISubSystem subsystem = getFileSubsystem(currentConnection);
-
- if (subsystem == null)
- throw new Exception(Messages.ErrorNoSubsystem);
-
- try {
- subsystem.connect(monitor, false);
- } catch (CoreException e) {
- throw e;
- } catch (OperationCanceledException e) {
- throw new CoreException(Status.CANCEL_STATUS);
- }
-
- if (!subsystem.isConnected())
- throw new Exception(Messages.ErrorConnectSubsystem);
-
- return ((IFileServiceSubSystem) subsystem).getFileService();
+ return null;
}
public static ISubSystem getFileSubsystem(IHost host) { @@ -94,27 +83,6 @@ public class RemoteHelper {
return null;
}
- public static IService getConnectedShellService(
- IHost currentConnection, IProgressMonitor monitor) throws Exception {
- final ISubSystem subsystem = getShellSubsystem(currentConnection);
-
- if (subsystem == null)
- throw new Exception(Messages.ErrorNoSubsystem);
-
- try {
- subsystem.connect(monitor, false);
- } catch (CoreException e) {
- throw e;
- } catch (OperationCanceledException e) {
- throw new CoreException(Status.CANCEL_STATUS);
- }
-
- if (!subsystem.isConnected())
- throw new Exception(Messages.ErrorConnectSubsystem);
-
- return ((IShellServiceSubSystem) subsystem).getShellService();
- }
-
public static ISubSystem getShellSubsystem(IHost host) {
if (host == null)
return null;
@@ -161,7 +129,7 @@ public class RemoteHelper {
IFileService fileService;
try {
- fileService = (IFileService) getConnectedRemoteFileService(
+ fileService = getConnectedRemoteFileService(
connection,
new SubProgressMonitor(monitor, 5));
InputStream inputStream = FileLocator.openStream( @@ -204,7 +172,7 @@ public class RemoteHelper {
IFileService fileService;
try {
- fileService = (IFileService) getConnectedRemoteFileService(
+ fileService = getConnectedRemoteFileService(
connection,
new SubProgressMonitor(monitor, 10));
File file = new File(localExePath);
@@ -341,4 +309,195 @@ public class RemoteHelper {
return;
}
}
+ public static RemoteMachine getRemoteMachine(IHost connection){
+ if (!getMachines().containsKey(connection))
+ getMachines().put(connection, new RemoteMachine(connection));
+ return getMachines().get(connection);
+ }
+
+ private static Map<IHost, RemoteMachine> getMachines() {
+ if (machines == null)
+ machines = new HashMap<IHost, RemoteMachine>();
+ return machines;
+ }
+
+ public static MessageConsole getConsole(IHost connection) {
+ return getRemoteMachine(connection).getConsole();
+ }
+
+ public static CommandResponseHandler getCommandHandler(IHost connection) {
+ return getRemoteMachine(connection).getCmdHandler();
+ }
+
+ public static ProcessStreamBuffer processOutput(IProgressMonitor monitor, IHostShell hostShell, CommandResponseHandler cmdHandler) throws Exception {
+ return new CommandOutputProcessor(monitor, hostShell, cmdHandler, "").processOutput();
+ }
+
+ public static IHost getRemoteConnectionForURI(URI uri, IProgressMonitor monitor) {
+ if (uri == null)
+ return null;
+
+ String host = uri.getHost();
+ if (host == null) {
+ // this is a local connection
+ ISystemRegistry sr = RSECorePlugin.getTheSystemRegistry();
+ IHost local = null;
+ while (local == null) {
+ local = sr.getLocalHost();
+ }
+ return local;
+ }
+ ISystemRegistry sr = RSECorePlugin.getTheSystemRegistry();
+ IHost[] connections = sr.getHosts();
+
+ IHost unconnected = null;
+ for (IHost conn : connections) {
+ if (host.equalsIgnoreCase(conn.getHostName())) {
+ IRemoteFileSubSystem fss = getRemoteFileSubSystem(conn);
+ if (fss != null && fss.isConnected())
+ return conn;
+ unconnected = conn;
+ }
+ }
+
+ return unconnected;
+ }
+
+ public static IRemoteFileSubSystem getRemoteFileSubSystem(IHost host) {
+ IRemoteFileSubSystem candidate = null;
+ IRemoteFileSubSystem otherServiceCandidate = null;
+ IRemoteFileSubSystem[] subSystems =
+RemoteFileUtility.getFileSubSystems(host);
+
+ for (IRemoteFileSubSystem subSystem : subSystems) {
+ if (subSystem instanceof FileServiceSubSystem) {
+ if (subSystem.isConnected())
+ return subSystem;
+
+ if (otherServiceCandidate == null)
+ otherServiceCandidate = subSystem;
+
+ } else if (candidate == null || (subSystem.isConnected() && !candidate.isConnected()))
+ candidate = subSystem;
+
+ }
+ if (candidate != null && candidate.isConnected())
+ return candidate;
+ if (otherServiceCandidate != null)
+ return otherServiceCandidate;
+ return null;
+ }
+
+ public static IFileService getConnectedRemoteFileService(IHost connection, IProgressMonitor monitor) throws Exception {
+ return getRemoteMachine(connection).getRemoteFileService(monitor);
+ }
+
+ public static IHostFile[] getRemoteDirContent(IHost connection, String
+remoteParent, String fileFilter, int fileType, IProgressMonitor
+monitor){
+
+ try {
+ IFileService fileServ = getConnectedRemoteFileService(connection, monitor);
+ return fileServ.list(remoteParent, fileFilter, fileType, monitor);
+ } catch (SystemMessageException e) {
+ e.printStackTrace();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ return null;
+ }
+
+ public static IService getConnectedShellService(IHost connection, IProgressMonitor monitor) throws Exception {
+ return getRemoteMachine(connection).getShellService(monitor);
+ }
+
+ public static void handleRunCommandRemote(IHost connection, YoctoCommand cmd, IProgressMonitor monitor){
+ try {
+ CommandRunnable cmdRun = new CommandRunnable(connection, cmd, monitor);
+ cmdRun.run();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ public static IHostShell runCommandRemote(IHost connection, YoctoCommand cmd,
+ IProgressMonitor monitor) throws CoreException {
+
+ monitor.beginTask(NLS.bind(Messages.RemoteShellExec_1,
+ cmd, cmd.getArguments()), 10);
+
+ String remoteCommand = cmd.getCommand() + " " + cmd.getArguments() +
+" ; echo " + TERMINATOR + "; exit ;";
+
+ IShellService shellService;
+ try {
+ shellService = (IShellService) getConnectedShellService(connection,
+new SubProgressMonitor(monitor, 7));
+
+ String env[] =
+getRemoteMachine(connection).prepareEnvString(monitor);
+
+ try {
+ IHostShell hostShell = shellService.runCommand(cmd.getInitialDirectory(), remoteCommand, env, new SubProgressMonitor(monitor, 3));
+ return hostShell;
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ } catch (Exception e1) {
+ e1.printStackTrace();
+ }
+ return null;
+ }
+
+ public static IHostFile getRemoteHostFile(IHost connection, String remoteFilePath, IProgressMonitor monitor){
+ assert(connection != null);
+ monitor.beginTask(Messages.InfoDownload, 100);
+
+ try {
+ IFileService fileService = getConnectedRemoteFileService(connection, new SubProgressMonitor(monitor, 10));
+ Path remotePath = new Path(remoteFilePath);
+ IHostFile remoteFile = fileService.getFile(remotePath.removeLastSegments(1).toString(), remotePath.lastSegment(), new SubProgressMonitor(monitor, 5));
+ return remoteFile;
+ } catch (Exception e) {
+ e.printStackTrace();
+ }finally {
+ monitor.done();
+ }
+ return null;
+ }
+
+ public static InputStream getRemoteInputStream(IHost connection, String parentPath, String remoteFilePath, IProgressMonitor monitor){
+ assert(connection != null);
+ monitor.beginTask(Messages.InfoDownload, 100);
+
+ try {
+ IFileService fileService = getConnectedRemoteFileService(connection,
+new SubProgressMonitor(monitor, 10));
+
+ return fileService.getInputStream(parentPath, remoteFilePath, false, monitor);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }finally {
+ monitor.done();
+ }
+ return null;
+ }
+
+ public static URI createNewURI(URI oldURI, String name) {
+ try {
+ String sep = oldURI.getPath().endsWith("/") ? "" : "/";
+ return new URI(oldURI.getScheme(), oldURI.getHost(), oldURI.getPath() + sep + name, oldURI.getFragment());
+ } catch (URISyntaxException e) {
+ e.printStackTrace();
+ return null;
+ }
+ }
+
+ public static boolean fileExistsRemote(IHost conn, IProgressMonitor monitor, String path) {
+ try {
+ IFileService fs = getConnectedRemoteFileService(conn, monitor);
+ int nameStart = path.lastIndexOf("/");
+ String parentPath = path.substring(0, nameStart);
+ String name = path.substring(nameStart + 1);
+ IHostFile hostFile = fs.getFile(parentPath, name, monitor);
+
+ return hostFile.exists();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ return false;
+ }
}
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..123a972
--- /dev/null
+++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/RemoteMa
+++ chine.java
@@ -0,0 +1,206 @@
+package org.yocto.remote.utils;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.core.runtime.OperationCanceledException;
+import org.eclipse.core.runtime.Status; import
+org.eclipse.core.runtime.SubProgressMonitor;
+import org.eclipse.rse.core.model.IHost; import
+org.eclipse.rse.core.subsystems.ISubSystem;
+import
+org.eclipse.rse.internal.services.local.shells.LocalShellService;
+import
+org.eclipse.rse.services.clientserver.messages.SystemMessageException;
+import org.eclipse.rse.services.files.IFileService;
+import org.eclipse.rse.services.shells.IHostShell;
+import org.eclipse.rse.services.shells.IShellService;
+import
+org.eclipse.rse.subsystems.files.core.servicesubsystem.IFileServiceSubS
+ystem; import
+org.eclipse.rse.subsystems.shells.core.subsystems.servicesubsystem.IShe
+llServiceSubSystem; import org.eclipse.ui.console.MessageConsole;
+
+public class RemoteMachine {
+ public static final String PROXY = "proxy";
+
+ private Map<String, String> environment;
+ private MessageConsole console;
+ private CommandResponseHandler cmdHandler;
+ private IHostShell hostShell;
+ private IShellService shellService;
+ private IHost connection;
+
+ private ISubSystem fileSubSystem;
+ private IFileService fileService;
+
+ public RemoteMachine(IHost connection) {
+ setConnection(connection);
+ }
+
+ public String[] prepareEnvString(IProgressMonitor monitor){
+ String[] env = null;
+ try {
+ if (shellService instanceof LocalShellService) {
+ env = shellService.getHostEnvironment();
+ } else {
+ List<String> envList = new ArrayList<String>();
+ getRemoteEnvProxyVars(monitor);
+ String value = "";
+ for (String varName : environment.keySet()){
+ value = varName + "=" + environment.get(varName);
+ envList.add(value);
+ }
+ env = envList.toArray(new String[envList.size()]);
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ return env;
+ }
+ public void getRemoteEnvProxyVars(IProgressMonitor monitor){
+ try {
+ if (environment != null && !environment.isEmpty())
+ return;
+
+ environment = new HashMap<String, String>();
+
+ IShellService shellService = getShellService(new
+SubProgressMonitor(monitor, 7));
+
+ ProcessStreamBuffer buffer = null;
+ try {
+ SubProgressMonitor subMonitor = new SubProgressMonitor(monitor, 3);
+ IHostShell hostShell = shellService.runCommand("", "env" + " ; echo " + RemoteHelper.TERMINATOR + "; exit;", new String[]{}, subMonitor);
+ buffer = RemoteHelper.processOutput(subMonitor, hostShell, cmdHandler);
+ for(int i = 0; i < buffer.getOutputLines().size(); i++) {
+ String out = buffer.getOutputLines().get(i);
+ String[] tokens = out.split("=");
+ if (tokens.length != 2)
+ continue;
+ String varName = tokens[0];
+ String varValue = tokens[1];
+ if (varName.contains(PROXY))
+ environment.put(varName, varValue);
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+
+ public Map<String, String> getEnvironment() {
+ return environment;
+ }
+ public void setEnvironment(Map<String, String> environment) {
+ this.environment = environment;
+ }
+ public MessageConsole getConsole() {
+ if (console == null)
+ console = ConsoleHelper.findConsole(ConsoleHelper.YOCTO_CONSOLE);
+
+ ConsoleHelper.showConsole(console);
+ return console;
+ }
+ public CommandResponseHandler getCmdHandler() {
+ if (cmdHandler == null)
+ cmdHandler = new CommandResponseHandler(getConsole());
+ return cmdHandler;
+ }
+ public IHostShell getHostShell() {
+ try {
+ if (hostShell == null) {
+ hostShell = getShellService(new NullProgressMonitor()).launchShell("", new String[]{}, new NullProgressMonitor());
+ prepareEnvString(new NullProgressMonitor());
+ }
+ } catch (SystemMessageException e) {
+ e.printStackTrace();
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ return hostShell;
+ }
+
+ public IShellService getShellService(IProgressMonitor monitor) throws Exception {
+ if (shellService != null)
+ return shellService;
+
+ final ISubSystem subsystem = getShellSubsystem();
+
+ if (subsystem == null)
+ throw new Exception(Messages.ErrorNoSubsystem);
+
+ try {
+ subsystem.connect(monitor, false);
+ } catch (CoreException e) {
+ throw e;
+ } catch (OperationCanceledException e) {
+ throw new CoreException(Status.CANCEL_STATUS);
+ }
+
+ if (!subsystem.isConnected())
+ throw new Exception(Messages.ErrorConnectSubsystem);
+
+ shellService = ((IShellServiceSubSystem) subsystem).getShellService();
+ return shellService;
+ }
+
+ private ISubSystem getShellSubsystem() {
+ if (connection == null)
+ return null;
+ ISubSystem[] subSystems = connection.getSubSystems();
+ for (int i = 0; i < subSystems.length; i++) {
+ if (subSystems[i] instanceof IShellServiceSubSystem)
+ return subSystems[i];
+ }
+ return null;
+ }
+
+ public IHost getConnection() {
+ return connection;
+ }
+ public void setConnection(IHost connection) {
+ this.connection = connection;
+ }
+
+ public IFileService getRemoteFileService(IProgressMonitor monitor) throws Exception {
+ if (fileService == null) {
+
+ while(getFileSubsystem() == null)
+ Thread.sleep(2);
+ try {
+ getFileSubsystem().connect(monitor, false);
+ } catch (CoreException e) {
+ throw e;
+ } catch (OperationCanceledException e) {
+ throw new CoreException(Status.CANCEL_STATUS);
+ }
+
+ if (!getFileSubsystem().isConnected())
+ throw new Exception(Messages.ErrorConnectSubsystem);
+
+ fileService = ((IFileServiceSubSystem) getFileSubsystem()).getFileService();
+ }
+ return fileService;
+ }
+
+ public ISubSystem getFileSubsystem() {
+ if (fileSubSystem == null) {
+ if (connection == null)
+ return null;
+ ISubSystem[] subSystems = connection.getSubSystems();
+ for (int i = 0; i < subSystems.length; i++) {
+ if (subSystems[i] instanceof IFileServiceSubSystem) {
+ fileSubSystem = subSystems[i];
+ break;
+ }
+ }
+ }
+ return fileSubSystem;
+ }
+
+}
diff --git a/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/Session.java b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/Session.java
new file mode 100644
index 0000000..cb14c0b
--- /dev/null
+++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/Session.
+++ java
@@ -0,0 +1,117 @@
+package org.yocto.remote.utils;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.NullProgressMonitor;
+import org.eclipse.rse.core.model.IHost; import
+org.eclipse.rse.services.files.IHostFile;
+
+public abstract class Session {
+ public static final String LT = System.getProperty("line.separator");
+ public static final String EXPORT_CMD = "export
+BB_ENV_EXTRAWHITE=\"DISABLE_SANITY_CHECKS $BB_ENV_EXTRAWHITE\"";
+
+ private final String initCmd;
+ private final IHostFile root;
+
+ public String terminator;
+ private volatile boolean interrupt = false;
+ private Process process;
+ private final OutputStream pos = null;
+ private IHost connection;
+
+ public Session(IHostFile root, String initCmd) throws IOException {
+ this.root = root;
+ this.initCmd = initCmd;
+ initializeConnection();
+ initializeShell(new NullProgressMonitor());
+ }
+
+ protected abstract void initializeConnection();
+
+ private void initializeShell(IProgressMonitor monitor) throws IOException {
+ try {
+ if (root != null) {
+ RemoteHelper.handleRunCommandRemote(connection, new YoctoCommand("source " + initCmd, root.getAbsolutePath(), ""), monitor);
+ RemoteHelper.handleRunCommandRemote(connection, new YoctoCommand(EXPORT_CMD, root.getAbsolutePath(), ""), monitor);
+ } else {
+ throw new Exception("Root file not found!");
+ }
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ synchronized
+ public void execute(String command, String terminator, ICommandResponseHandler handler) throws IOException {
+ interrupt = false;
+ InputStream errIs = process.getErrorStream();
+ if (errIs.available() > 0) {
+ clearErrorStream(errIs);
+ }
+ sendToProcessAndTerminate(command);
+
+ BufferedReader br = new BufferedReader(new InputStreamReader(process.getInputStream()));
+ String std = null;
+
+ do {
+ if (errIs.available() > 0) {
+ byte[] msg = new byte[errIs.available()];
+
+ errIs.read(msg, 0, msg.length);
+ handler.response(new String(msg), true);
+ }
+
+ std = br.readLine();
+
+ if (std != null && !std.endsWith(terminator)) {
+ handler.response(std, false);
+ }
+
+ } while (std != null && !std.endsWith(terminator) && !interrupt);
+
+ if (interrupt) {
+ process.destroy();
+ initializeShell(null);
+ interrupt = false;
+ }
+ }
+
+ private void clearErrorStream(InputStream is) {
+
+ try {
+ byte b[] = new byte[is.available()];
+ is.read(b);
+ System.out.println("clearing: " + new String(b));
+ } catch (IOException e) {
+ e.printStackTrace();
+ //Ignore any error
+ }
+ }
+ /**
+ * Send command string to shell process and add special terminator string so
+ * reader knows when output is complete.
+ *
+ * @param command
+ * @throws IOException
+ */
+ private void sendToProcessAndTerminate(String command) throws IOException {
+ pos.write(command.getBytes());
+ pos.write(LT.getBytes());
+ pos.flush();
+ pos.write("echo $?".getBytes());
+ pos.write(terminator.getBytes());
+ pos.write(LT.getBytes());
+ pos.flush();
+ }
+
+ /**
+ * Interrupt any running processes.
+ */
+ public void interrupt() {
+ interrupt = true;
+ }
+}
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..0cd7dcd
--- /dev/null
+++ b/plugins/org.yocto.remote.utils/src/org/yocto/remote/utils/YoctoCom
+++ mand.java
@@ -0,0 +1,53 @@
+package org.yocto.remote.utils;
+
+
+public class YoctoCommand {
+ private String command;
+ private String initialDirectory;
+ private String arguments;
+ private ProcessStreamBuffer processBuffer;
+
+ public YoctoCommand(String command, String initialDirectory, String arguments){
+ this.setCommand(command);
+ this.setInitialDirectory(initialDirectory);
+ this.setArguments(arguments);
+ this.setProcessBuffer(new ProcessStreamBuffer(false));
+ }
+
+ public String getCommand() {
+ return command;
+ }
+
+ public void setCommand(String command) {
+ this.command = command;
+ }
+
+ public String getInitialDirectory() {
+ return initialDirectory;
+ }
+
+ public void setInitialDirectory(String initialDirectory) {
+ this.initialDirectory = initialDirectory;
+ }
+
+ public String getArguments() {
+ return arguments;
+ }
+
+ public void setArguments(String arguments) {
+ this.arguments = arguments;
+ }
+
+ public ProcessStreamBuffer getProcessBuffer() {
+ return processBuffer;
+ }
+
+ public void setProcessBuffer(ProcessStreamBuffer processBuffer) {
+ this.processBuffer = processBuffer;
+ }
+
+ @Override
+ public String toString() {
+ return command + " " + arguments;
+ }
+}
--
1.7.9.5
_______________________________________________
yocto mailing list
yocto at yoctoproject.org
https://lists.yoctoproject.org/listinfo/yocto
More information about the yocto
mailing list