1 files changed, 202 insertions, 0 deletions

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 @@
+/*******************************************************************************
+ * Copyright (c) 2013 Intel Corporation.
+ * 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:
+ * Ioana Grigoropol(Intel) - initial API and implementation
+ *******************************************************************************/
+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.IFileServiceSubSystem;
+import org.eclipse.rse.subsystems.shells.core.subsystems.servicesubsystem.IShellServiceSubSystem;
+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 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 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;
+        }
+
+}