bundles/org.eclipse.remote.proxy.core/src/org/eclipse/remote/internal/proxy/core/ProxyConnectionBootstrap.java - ptp/org.eclipse.remote - Git at Google

 /*******************************************************************************
  * Copyright (c) 2016 Oak Ridge National Laboratory and others.
  * 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
  *******************************************************************************/
 package org.eclipse.remote.internal.proxy.core;

 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.IOException;
 import java.io.InputStreamReader;
 import java.io.OutputStreamWriter;
 import java.net.URL;
 import java.util.Arrays;
 import java.util.Base64;

 import org.eclipse.core.runtime.CoreException;
 import org.eclipse.core.runtime.FileLocator;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.Path;
 import org.eclipse.core.runtime.Platform;
 import org.eclipse.core.runtime.SubMonitor;
 import org.eclipse.jsch.core.IJSchService;
 import org.eclipse.remote.core.IRemoteConnection;
 import org.eclipse.remote.core.IRemoteConnectionHostService;
 import org.eclipse.remote.core.IRemoteConnectionWorkingCopy;
 import org.eclipse.remote.core.IUserAuthenticatorService;
 import org.eclipse.remote.core.exception.RemoteConnectionException;
 import org.eclipse.remote.internal.jsch.core.JSchUserInfo;
 import org.eclipse.remote.proxy.protocol.core.StreamChannelManager;
 import org.osgi.framework.Bundle;

 import com.jcraft.jsch.Channel;
 import com.jcraft.jsch.ChannelExec;
 import com.jcraft.jsch.JSchException;
 import com.jcraft.jsch.Session;

 public class ProxyConnectionBootstrap {
 	private final IJSchService jSchService;
 	private Session session;
 	private ChannelExec exec;

 	private class Context {
 		private State state;
 		private String osName;
 		private String osArch;

 		private final SubMonitor monitor;
 		private final BufferedReader reader;
 		private final BufferedWriter writer;

 		public Context(BufferedReader reader, BufferedWriter writer, IProgressMonitor monitor) {
 			this.reader = reader;
 			this.writer = writer;
 			this.monitor = SubMonitor.convert(monitor);
 			setState(States.INIT);
 		}

 	    State getState() {
 	    	return state;
 	    }

 	    SubMonitor getMonitor() {
 	    	return monitor;
 	    }

 	    void setState(State state) {
 	    	this.state = state;
 	    }

 	    String getOSName() {
 	    	return osName;
 	    }

 	    void setOSName(String osName) {
 	    	this.osName = osName;
 	    }

 	    String getOSArch() {
 	    	return osArch;
 	    }

 	    void setOSArch(String osArch) {
 	    	this.osArch = osArch;
 	    }
 	}

 	private interface State {
 	    /**
 	       * @return true to keep processing, false to read more data.
 	     */
 	    boolean process(Context context) throws IOException;
 	}

 	private enum States implements State {
 		INIT {
 			@Override
 			public boolean process(Context context) throws IOException {
 				context.getMonitor().subTask("Initializing");
 				String line = context.reader.readLine();
 				context.getMonitor().worked(1);
 				if (line.equals("running")) {
 					context.setState(States.CHECK);
 					return true;
 				}
 				return false;
 			}
 		},
 		CHECK {
 			@Override
 			public boolean process(Context context) throws IOException {
 				context.getMonitor().subTask("Validating environment");
 				String bundleName = "org.eclipse.remote.proxy.server.core";
 				Bundle serverBundle = Platform.getBundle(bundleName);
 				if (serverBundle == null) {
 					throw new IOException("Unable to locate server bundle " + bundleName);
 				}
 				context.writer.write("check " + serverBundle.getVersion() + "\n");
 				context.writer.flush();
 				String line = context.reader.readLine();
 				while (line != null) {
 					context.getMonitor().worked(2);
 					String[] parts = line.split(":");
 					switch (parts[0]) {
 					case "ok":
 						String[] status = parts[1].split("/");
 						context.setOSName(status[1]);
 						context.setOSArch(status[2]);
 						context.setState(status[0].equals("proxy") ? States.START : States.DOWNLOAD);
 						return true;
 					case "fail":
 						System.out.println("fail:"+parts[1]);
 						return false;
 					case "debug":
 						System.err.println(line);
 						break;
 					default:
 						System.err.println("Invalid response from bootstrap script: " + line);
 						return false;
 					}
 					line = context.reader.readLine();
 				}
 				return false;
 			}
 		},
 		DOWNLOAD {
 			@Override
 			public boolean process(Context context) throws IOException {
 				context.getMonitor().subTask("Updating server proxy");
 				String bundleName = "org.eclipse.remote.proxy.server." + context.getOSName() + "." + context.getOSArch();
 				Bundle serverBundle = Platform.getBundle(bundleName);
 				if (serverBundle == null) {
 					throw new IOException("Unable to locate server bundle " + bundleName);
 				}
 				URL fileURL = FileLocator.find(serverBundle, new Path("proxy.server.tar.gz"), null);
 				if (fileURL == null) {
 					return false;
 				}
 				File file = new File(FileLocator.toFileURL(fileURL).getFile());
 				long count = file.length() / 510;
 				context.writer.write("download " + count + "\n");
 				context.writer.flush();
 				context.getMonitor().worked(2);
 				if (downloadFile(file, context.writer, context.getMonitor().newChild(5))) {
 					String line = context.reader.readLine();
 					while (line != null) {
 						String[] parts = line.split(":");
 						switch (parts[0]) {
 						case "ok":
 							context.setState(States.START);
 							return true;
 						case "fail":
 							System.out.println("fail:"+parts[1]);
 							return false;
 						case "debug":
 							System.err.println(line);
 							break;
 						default:
 							System.err.println("Invalid response from bootstrap script: " + line);
 							return false;
 						}
 						line = context.reader.readLine();
 					}
 				}
 				return false;
 			}

 			private boolean downloadFile(File file, BufferedWriter writer, IProgressMonitor monitor) {
 				SubMonitor subMon = SubMonitor.convert(monitor, 10);
 				try {
 					Base64.Encoder encoder = Base64.getEncoder();
 					FileInputStream in = new FileInputStream(file);
 					byte[] buf = new byte[510]; // Multiple of 3
 					int n;
 					while ((n = in.read(buf)) >= 0) {
 						if (n < 510) {
 							writer.write(encoder.encodeToString(Arrays.copyOf(buf, n)) + "\n");
 						} else {
 							writer.write(encoder.encodeToString(buf));
 						}
 						subMon.setWorkRemaining(8);
 					}
 					writer.flush();
 					in.close();
 					return true;
 				} catch (IOException e) {
 					return false;
 				}
 			}
 		},
 		START {
 			@Override
 			public boolean process(Context context) throws IOException {
 				context.getMonitor().subTask("Starting server");
 				context.writer.write("start\n");
 				context.writer.flush();
 				return false; // Finished
 			}
 		}
 	}

 	public ProxyConnectionBootstrap() {
 		jSchService = Activator.getService(IJSchService.class);
 	}

 	public StreamChannelManager run(IRemoteConnection connection, IProgressMonitor monitor) throws RemoteConnectionException {
 		SubMonitor subMon = SubMonitor.convert(monitor, 20);
 		try {
 			final Channel chan = openChannel(connection, subMon.newChild(10));
 			BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(chan.getOutputStream()));
 			BufferedReader reader = new BufferedReader(new InputStreamReader(chan.getInputStream()));
 			subMon.beginTask("Checking server installation", 10);
 			subMon.subTask("Loading bootstrap shell");
 			URL fileURL = FileLocator.find(Activator.getDefault().getBundle(), new Path("bootstrap.sh"), null);
 			if (fileURL == null) {
 				throw new RemoteConnectionException("Unable to locate bootstrap shell");
 			}
 			File file = new File(FileLocator.toFileURL(fileURL).getFile());
 			BufferedReader scriptReader = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
 			String line;
 			while ((line = scriptReader.readLine()) != null) {
 				writer.write(line + "\n");
 			}
 			scriptReader.close();
 			writer.flush();
 			subMon.worked(2);
 			Context context = new Context(reader, writer, subMon.newChild(8));
 			while (context.getState().process(context)) {
 				// do state machine
 			}
 			if (context.getState() != States.START) {
 				context.writer.write("exit\n");
 				context.writer.flush();
 				throw new RemoteConnectionException("Unable to start server");
 			}
 			new Thread("server error stream") {
 				@Override
 				public void run() {
 					try {
 						BufferedReader reader = new BufferedReader(new InputStreamReader(chan.getExtInputStream()));
 						String line;
 						while ((line = reader.readLine()) != null) {
 							System.err.println("server: "+ line);
 						}
 					} catch (IOException e) {
 						// Ignore and terminate thread
 					}
 				}
 			}.start();
 			return new StreamChannelManager(chan.getInputStream(), chan.getOutputStream());
 		} catch (IOException | CoreException e) {
 			throw new RemoteConnectionException(e.getMessage());
 		}
 	}

 	private Channel openChannel(IRemoteConnection connection, IProgressMonitor monitor) throws RemoteConnectionException {
 		IRemoteConnectionWorkingCopy wc = connection.getWorkingCopy();
 		IRemoteConnectionHostService hostService = wc.getService(IRemoteConnectionHostService.class);
 		IUserAuthenticatorService authService = wc.getService(IUserAuthenticatorService.class);
 		try {
 			session = jSchService.createSession(hostService.getHostname(), hostService.getPort(), hostService.getUsername());
 			session.setUserInfo(new JSchUserInfo(hostService, authService));
 			if (hostService.usePassword()) {
 				session.setConfig("PreferredAuthentications", "password,keyboard-interactive,gssapi-with-mic,publickey"); //$NON-NLS-1$ //$NON-NLS-2$
 			} else {
 				session.setConfig("PreferredAuthentications", "publickey,gssapi-with-mic,password,keyboard-interactive"); //$NON-NLS-1$ //$NON-NLS-2$
 			}
 			String password = hostService.getPassword();
 			if (!password.isEmpty()) {
 				session.setPassword(password);
 			}
 			jSchService.connect(session, hostService.getTimeout() * 1000, monitor);
 			if (monitor.isCanceled()) {
 				throw new RemoteConnectionException("User canceled connection open");
 			}
 			exec = (ChannelExec) session.openChannel("exec"); //$NON-NLS-1$
 			exec.setCommand("/bin/sh -l");
 			exec.connect();
 			return exec;
 		} catch (JSchException e) {
 			throw new RemoteConnectionException(e.getMessage());
 		}
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2016 Oak Ridge National Laboratory and others.
	* 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
	*******************************************************************************/
	package org.eclipse.remote.internal.proxy.core;

	import java.io.BufferedReader;
	import java.io.BufferedWriter;
	import java.io.File;
	import java.io.FileInputStream;
	import java.io.IOException;
	import java.io.InputStreamReader;
	import java.io.OutputStreamWriter;
	import java.net.URL;
	import java.util.Arrays;
	import java.util.Base64;

	import org.eclipse.core.runtime.CoreException;
	import org.eclipse.core.runtime.FileLocator;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.Path;
	import org.eclipse.core.runtime.Platform;
	import org.eclipse.core.runtime.SubMonitor;
	import org.eclipse.jsch.core.IJSchService;
	import org.eclipse.remote.core.IRemoteConnection;
	import org.eclipse.remote.core.IRemoteConnectionHostService;
	import org.eclipse.remote.core.IRemoteConnectionWorkingCopy;
	import org.eclipse.remote.core.IUserAuthenticatorService;
	import org.eclipse.remote.core.exception.RemoteConnectionException;
	import org.eclipse.remote.internal.jsch.core.JSchUserInfo;
	import org.eclipse.remote.proxy.protocol.core.StreamChannelManager;
	import org.osgi.framework.Bundle;

	import com.jcraft.jsch.Channel;
	import com.jcraft.jsch.ChannelExec;
	import com.jcraft.jsch.JSchException;
	import com.jcraft.jsch.Session;

	public class ProxyConnectionBootstrap {
	private final IJSchService jSchService;
	private Session session;
	private ChannelExec exec;

	private class Context {
	private State state;
	private String osName;
	private String osArch;

	private final SubMonitor monitor;
	private final BufferedReader reader;
	private final BufferedWriter writer;

	public Context(BufferedReader reader, BufferedWriter writer, IProgressMonitor monitor) {
	this.reader = reader;
	this.writer = writer;
	this.monitor = SubMonitor.convert(monitor);
	setState(States.INIT);
	}

	State getState() {
	return state;
	}

	SubMonitor getMonitor() {
	return monitor;
	}

	void setState(State state) {
	this.state = state;
	}

	String getOSName() {
	return osName;
	}

	void setOSName(String osName) {
	this.osName = osName;
	}

	String getOSArch() {
	return osArch;
	}

	void setOSArch(String osArch) {
	this.osArch = osArch;
	}
	}

	private interface State {
	/**
	* @return true to keep processing, false to read more data.
	*/
	boolean process(Context context) throws IOException;
	}

	private enum States implements State {
	INIT {
	@Override
	public boolean process(Context context) throws IOException {
	context.getMonitor().subTask("Initializing");
	String line = context.reader.readLine();
	context.getMonitor().worked(1);
	if (line.equals("running")) {
	context.setState(States.CHECK);
	return true;
	}
	return false;
	}
	},
	CHECK {
	@Override
	public boolean process(Context context) throws IOException {
	context.getMonitor().subTask("Validating environment");
	String bundleName = "org.eclipse.remote.proxy.server.core";
	Bundle serverBundle = Platform.getBundle(bundleName);
	if (serverBundle == null) {
	throw new IOException("Unable to locate server bundle " + bundleName);
	}
	context.writer.write("check " + serverBundle.getVersion() + "\n");
	context.writer.flush();
	String line = context.reader.readLine();
	while (line != null) {
	context.getMonitor().worked(2);
	String[] parts = line.split(":");
	switch (parts[0]) {
	case "ok":
	String[] status = parts[1].split("/");
	context.setOSName(status[1]);
	context.setOSArch(status[2]);
	context.setState(status[0].equals("proxy") ? States.START : States.DOWNLOAD);
	return true;
	case "fail":
	System.out.println("fail:"+parts[1]);
	return false;
	case "debug":
	System.err.println(line);
	break;
	default:
	System.err.println("Invalid response from bootstrap script: " + line);
	return false;
	}
	line = context.reader.readLine();
	}
	return false;
	}
	},
	DOWNLOAD {
	@Override
	public boolean process(Context context) throws IOException {
	context.getMonitor().subTask("Updating server proxy");
	String bundleName = "org.eclipse.remote.proxy.server." + context.getOSName() + "." + context.getOSArch();
	Bundle serverBundle = Platform.getBundle(bundleName);
	if (serverBundle == null) {
	throw new IOException("Unable to locate server bundle " + bundleName);
	}
	URL fileURL = FileLocator.find(serverBundle, new Path("proxy.server.tar.gz"), null);
	if (fileURL == null) {
	return false;
	}
	File file = new File(FileLocator.toFileURL(fileURL).getFile());
	long count = file.length() / 510;
	context.writer.write("download " + count + "\n");
	context.writer.flush();
	context.getMonitor().worked(2);
	if (downloadFile(file, context.writer, context.getMonitor().newChild(5))) {
	String line = context.reader.readLine();
	while (line != null) {
	String[] parts = line.split(":");
	switch (parts[0]) {
	case "ok":
	context.setState(States.START);
	return true;
	case "fail":
	System.out.println("fail:"+parts[1]);
	return false;
	case "debug":
	System.err.println(line);
	break;
	default:
	System.err.println("Invalid response from bootstrap script: " + line);
	return false;
	}
	line = context.reader.readLine();
	}
	}
	return false;
	}

	private boolean downloadFile(File file, BufferedWriter writer, IProgressMonitor monitor) {
	SubMonitor subMon = SubMonitor.convert(monitor, 10);
	try {
	Base64.Encoder encoder = Base64.getEncoder();
	FileInputStream in = new FileInputStream(file);
	byte[] buf = new byte[510]; // Multiple of 3
	int n;
	while ((n = in.read(buf)) >= 0) {
	if (n < 510) {
	writer.write(encoder.encodeToString(Arrays.copyOf(buf, n)) + "\n");
	} else {
	writer.write(encoder.encodeToString(buf));
	}
	subMon.setWorkRemaining(8);
	}
	writer.flush();
	in.close();
	return true;
	} catch (IOException e) {
	return false;
	}
	}
	},
	START {
	@Override
	public boolean process(Context context) throws IOException {
	context.getMonitor().subTask("Starting server");
	context.writer.write("start\n");
	context.writer.flush();
	return false; // Finished
	}
	}
	}

	public ProxyConnectionBootstrap() {
	jSchService = Activator.getService(IJSchService.class);
	}

	public StreamChannelManager run(IRemoteConnection connection, IProgressMonitor monitor) throws RemoteConnectionException {
	SubMonitor subMon = SubMonitor.convert(monitor, 20);
	try {
	final Channel chan = openChannel(connection, subMon.newChild(10));
	BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(chan.getOutputStream()));
	BufferedReader reader = new BufferedReader(new InputStreamReader(chan.getInputStream()));
	subMon.beginTask("Checking server installation", 10);
	subMon.subTask("Loading bootstrap shell");
	URL fileURL = FileLocator.find(Activator.getDefault().getBundle(), new Path("bootstrap.sh"), null);
	if (fileURL == null) {
	throw new RemoteConnectionException("Unable to locate bootstrap shell");
	}
	File file = new File(FileLocator.toFileURL(fileURL).getFile());
	BufferedReader scriptReader = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
	String line;
	while ((line = scriptReader.readLine()) != null) {
	writer.write(line + "\n");
	}
	scriptReader.close();
	writer.flush();
	subMon.worked(2);
	Context context = new Context(reader, writer, subMon.newChild(8));
	while (context.getState().process(context)) {
	// do state machine
	}
	if (context.getState() != States.START) {
	context.writer.write("exit\n");
	context.writer.flush();
	throw new RemoteConnectionException("Unable to start server");
	}
	new Thread("server error stream") {
	@Override
	public void run() {
	try {
	BufferedReader reader = new BufferedReader(new InputStreamReader(chan.getExtInputStream()));
	String line;
	while ((line = reader.readLine()) != null) {
	System.err.println("server: "+ line);
	}
	} catch (IOException e) {
	// Ignore and terminate thread
	}
	}
	}.start();
	return new StreamChannelManager(chan.getInputStream(), chan.getOutputStream());
	} catch (IOException \| CoreException e) {
	throw new RemoteConnectionException(e.getMessage());
	}
	}

	private Channel openChannel(IRemoteConnection connection, IProgressMonitor monitor) throws RemoteConnectionException {
	IRemoteConnectionWorkingCopy wc = connection.getWorkingCopy();
	IRemoteConnectionHostService hostService = wc.getService(IRemoteConnectionHostService.class);
	IUserAuthenticatorService authService = wc.getService(IUserAuthenticatorService.class);
	try {
	session = jSchService.createSession(hostService.getHostname(), hostService.getPort(), hostService.getUsername());
	session.setUserInfo(new JSchUserInfo(hostService, authService));
	if (hostService.usePassword()) {
	session.setConfig("PreferredAuthentications", "password,keyboard-interactive,gssapi-with-mic,publickey"); //$NON-NLS-1$ //$NON-NLS-2$
	} else {
	session.setConfig("PreferredAuthentications", "publickey,gssapi-with-mic,password,keyboard-interactive"); //$NON-NLS-1$ //$NON-NLS-2$
	}
	String password = hostService.getPassword();
	if (!password.isEmpty()) {
	session.setPassword(password);
	}
	jSchService.connect(session, hostService.getTimeout() * 1000, monitor);
	if (monitor.isCanceled()) {
	throw new RemoteConnectionException("User canceled connection open");
	}
	exec = (ChannelExec) session.openChannel("exec"); //$NON-NLS-1$
	exec.setCommand("/bin/sh -l");
	exec.connect();
	return exec;
	} catch (JSchException e) {
	throw new RemoteConnectionException(e.getMessage());
	}
	}
	}