The Eclipse Foundation makes available all content in this plug-in ("Content"). Unless otherwise indicated below, the Content is provided to you under the terms and conditions of the
Eclipse Public License Version 1.0 ("EPL"). A copy of the EPL is available at http://www.eclipse.org/legal/epl-v10.html.
For purposes of the EPL, "Program" will mean the Content.
If you did not receive this Content directly from the Eclipse Foundation, the Content is being redistributed by another party ("Redistributor") and different terms and conditions may
apply to your use of any object code in the Content. Check the Redistributor's license that was provided with the Content. If no such license exists, contact the Redistributor. Unless otherwise
indicated below, the terms and conditions of the EPL still apply to any source code in the Content and such source code may be obtained at http://www.eclipse.org.
The Eclipse Foundation makes available all content in this plug-in ("Content"). Unless otherwise indicated below, the Content is provided to you under the terms and conditions of the
Eclipse Public License Version 1.0 ("EPL"). A copy of the EPL is available at http://www.eclipse.org/legal/epl-v10.html.
For purposes of the EPL, "Program" will mean the Content.
If you did not receive this Content directly from the Eclipse Foundation, the Content is being redistributed by another party ("Redistributor") and different terms and conditions may
apply to your use of any object code in the Content. Check the Redistributor's license that was provided with the Content. If no such license exists, contact the Redistributor. Unless otherwise
indicated below, the terms and conditions of the EPL still apply to any source code in the Content and such source code may be obtained at http://www.eclipse.org.
* Current flags are:
* {@link IRemoteProcessBuilder#NONE} - disable any flags
* {@link IRemoteProcessBuilder#ALLOCATE_PTY} - allocate a pseudo-terminal for the process (RFC-4254 Sec. 6.2)
* {@link IRemoteProcessBuilder#FORWARD_X11} - enable X11 forwarding (RFC-4254 Sec. 6.3)
*
*
* @param flags
* bitwise-or of flags
* @return remote process object
* @throws IOException
* @since 7.0
*/
public IRemoteProcess getCommandShell(int flags) throws IOException;
}
IRemoteConnection.java 0000664 0000000 0000000 00000012662 12721140017 0035170 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core /*******************************************************************************
* Copyright (c) 2007 IBM Corporation 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
*
* Contributors:
* IBM Corporation - Initial API and implementation
*******************************************************************************/
package org.eclipse.remote.core;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.remote.core.exception.RemoteConnectionException;
/**
* Represents a connection to a remote system. Use the getService method to get at connection
* specific services. Connections have state, open or closed. Some connection types are always
* open in which case the close does nothing. Connections have properties which are values that
* describe the connection and are discovered. Connections also have attributes which are
* client specified values that control the connection.
*
* @noimplement This interface is not intended to be implemented by clients.
*/
public interface IRemoteConnection {
/**
* The interface that is extend by services provided for this remote connection.
*
* @since 2.0
*/
interface Service {
IRemoteConnection getRemoteConnection();
interface Factory {
T getService(IRemoteConnection remoteConnection, Class service);
}
}
// Common properties
final static String OS_NAME_PROPERTY = "os.name"; //$NON-NLS-1$
final static String OS_VERSION_PROPERTY = "os.version"; //$NON-NLS-1$
final static String OS_ARCH_PROPERTY = "os.arch"; //$NON-NLS-1$
final static String FILE_SEPARATOR_PROPERTY = "file.separator"; //$NON-NLS-1$
final static String PATH_SEPARATOR_PROPERTY = "path.separator"; //$NON-NLS-1$
final static String LINE_SEPARATOR_PROPERTY = "line.separator"; //$NON-NLS-1$
final static String USER_HOME_PROPERTY = "user.home"; //$NON-NLS-1$
/**
* @since 2.0
*/
final static String LOCALE_CHARMAP_PROPERTY = "locale.charmap"; //$NON-NLS-1$
/**
* Get the connection type of this connection
*
* @return connection type
* @since 2.0
*/
public IRemoteConnectionType getConnectionType();
/**
* Get unique name for this connection.
*
* @return connection name
*/
public String getName();
/**
* Get the service for this remote connection that implements the given interface.
*
* @param service
* the interface the required service must implements
* @return the desired service or null if there is no such service available
* @throws CoreException
* @since 2.0
*/
T getService(Class service);
/**
* Does this connection support the given service.
*
* @param service
* The service to be tested
* @return true if this connection supports the service
* @since 2.0
*/
boolean hasService(Class service);
/**
* Open the connection. Must be called before the connection can be used.
*
* @param monitor
* the progress monitor to use for reporting progress to the user. It is the caller's responsibility to call done()
* on the given monitor. Accepts null, indicating that no progress should be reported and that the operation cannot
* be cancelled.
* @throws RemoteConnectionException
*/
public void open(IProgressMonitor monitor) throws RemoteConnectionException;
/**
* Close the connection. Must be called to terminate the connection.
*/
public void close();
/**
* Test if the connection is open.
*
* @return true if connection is open.
*/
public boolean isOpen();
/**
* Gets the remote system property indicated by the specified key. The connection must be open prior to calling this method.
*
* @param key
* the name of the property
* @return the string value of the property, or null if no property has that key
*/
public String getProperty(String key);
/**
* Get an attribute for a connection.
*
* NOTE: the attributes do not include any security related information (e.g. passwords, keys, etc.)
*
* @param key
* @return the attribute value, or empty string if not defined.
* @since 2.0
*/
public String getAttribute(String key);
/**
* Get an attribute that is stored in secure storage, such as passwords.
*
* @param key
* @return the attribute value, or empty string if not defined.
* @since 2.0
*/
public String getSecureAttribute(String key);
/**
* Return a working copy to allow setting and changing of attributes.
*
* @return working copy of remote
*/
public IRemoteConnectionWorkingCopy getWorkingCopy();
/**
* Register a listener that will be notified when this connection's status changes.
*
* @param listener
*/
public void addConnectionChangeListener(IRemoteConnectionChangeListener listener);
/**
* Remove a listener that will be notified when this connection's status changes.
*
* @param listener
*/
public void removeConnectionChangeListener(IRemoteConnectionChangeListener listener);
/**
* Notify all listeners when this connection's status changes. See {{@link RemoteConnectionChangeEvent} for a list of event
* types.
*
* @param event
* event type indicating the nature of the event
*/
public void fireConnectionChangeEvent(int type);
}
IRemoteConnectionChangeListener.java 0000664 0000000 0000000 00000002406 12721140017 0037777 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core /*******************************************************************************
* Copyright (c) 2008 IBM Corporation 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
*
* Contributors:
* IBM Corporation - Initial API and implementation
*******************************************************************************/
package org.eclipse.remote.core;
import java.util.EventListener;
/**
* Listener used to register for notification of connection status changes.
* Listeners can be registered on individual connections using
* {@link IRemoteConnection#addConnectionChangeListener(IRemoteConnectionChangeListener)},
* or globally for all connections using
* {@link IRemoteServicesManager#addRemoteConnectionChangeListener(IRemoteConnectionChangeListener)}.
*/
public interface IRemoteConnectionChangeListener extends EventListener {
/**
* Notifies this listener that the status of a connection has changed.
*
* @param event
* the connection change event
* @since 2.0
*/
public void connectionChanged(RemoteConnectionChangeEvent event);
}
IRemoteConnectionControlService.java 0000664 0000000 0000000 00000003231 12721140017 0040042 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core /*******************************************************************************
* Copyright (c) 2015 QNX Software Systems 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
*
* Contributors:
* QNX - initial API and implementation
*******************************************************************************/
package org.eclipse.remote.core;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.remote.core.exception.RemoteConnectionException;
/**
* A service to control and report on the state of a connection, open or closed.
* Connections that do not provide this service are always assumed to be opened.
*
* @since 2.0
*/
public interface IRemoteConnectionControlService extends IRemoteConnection.Service {
/**
* Open the connection. Must be called before the connection can be used.
*
* @param monitor
* the progress monitor to use for reporting progress to the user. It is the caller's responsibility to call done()
* on the given monitor. Accepts null, indicating that no progress should be reported and that the operation cannot
* be cancelled.
* @throws RemoteConnectionException
*/
public void open(IProgressMonitor monitor) throws RemoteConnectionException;
/**
* Close the connection. Must be called to terminate the connection.
*/
public void close();
/**
* Test if the connection is open.
*
* @return true if connection is open.
*/
public boolean isOpen();
}
IRemoteConnectionHostService.java 0000664 0000000 0000000 00000007006 12721140017 0037343 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core /*******************************************************************************
* Copyright (c) 2015 IBM Corporation 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
*
* Contributors:
* IBM Corporation - Initial API and implementation
*******************************************************************************/
package org.eclipse.remote.core;
/**
* A service to obtain host specific information.
*
* @since 2.0
*/
public interface IRemoteConnectionHostService extends IRemoteConnection.Service {
/**
* Obtain the hostname associated with this connection.
*
* @return hostname
*/
String getHostname();
/**
* Obtain the port associated with this connection
*
* @return port
*/
int getPort();
/**
* Obtain the timeout used when establishing the connection.
*
* @return timeout
*/
int getTimeout();
/**
* Obtain the flag that indicates a login shell should be started once the connection is established
*
* @return login shell flag
*/
boolean useLoginShell();
/**
* Obtain the username associated with this connection.
*
* @return
*/
String getUsername();
/**
* Set the hostname associated with this connection. Note, this method can only be used for an
* IRemoteConnectionWorkingCopy and will have no effect otherwise.
*
* @param hostname
* new hostname for connection
*/
void setHostname(String hostname);
/**
* Set the pass phrase associated with this connection. Note, this method can only be used for an
* IRemoteConnectionWorkingCopy and will have no effect otherwise.
*
* @param passphrase
*/
void setPassphrase(String passphrase);
/**
* Set the password associated with this connection. Note, this method can only be used for an
* IRemoteConnectionWorkingCopy and will have no effect otherwise.
*
* @param password
* new password for connection
*/
void setPassword(String password);
/**
* Set the port used for the connection. Note, this method can only be used forh an
* IRemoteConnectionWorkingCopy and will have no effect otherwise.
*
* @param port
* new port for connection
*/
void setPort(int port);
/**
* Set the timeout used when establishing the connection. A timeout of 0 means infinite. Note, this method can only be used
* for an IRemoteConnectionWorkingCopy and will have no effect otherwise.
*
* @param timeout
* new timeout value
*/
void setTimeout(int timeout);
/**
* Set the flag indicating a login shell should be stated for this connection. Note, this method can only be used
* for an IRemoteConnectionWorkingCopy and will have no effect otherwise.
*
* @param useLogingShell
* true to start a login shell
*/
void setUseLoginShell(boolean useLogingShell);
/**
* Set the connection to try password authentication first. Note, this method can only be used for an
* IRemoteConnectionWorkingCopy and will have no effect otherwise.
*
* @param usePassword
* use password authentication
*/
void setUsePassword(boolean usePassword);
/**
* Set the username associated with this connection. Note, this method can only be used for an
* IRemoteConnectionWorkingCopy and will have no effect otherwise.
*
* @param username
* new username for connection
*/
void setUsername(String username);
}
IRemoteConnectionPropertyService.java 0000664 0000000 0000000 00000002716 12721140017 0040255 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core /*******************************************************************************
* Copyright (c) 2015 QNX Software Systems 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
*
* Contributors:
* QNX - initial API and implementation
*******************************************************************************/
package org.eclipse.remote.core;
/**
* A connection property is some descriptive information that's discovered about the connection.
* This service provides property values for a connection.
*
* Examples include:
*
* os.name Operating system name
* os.arch Operating system architecture
* os.version Operating system version
* file.separator File separator ("/" on UNIX)
* path.separator Path separator (":" on UNIX)
* line.separator Line separator ("\n" on UNIX)
* user.home Home directory
*
*
* @since 2.0
*/
public interface IRemoteConnectionPropertyService extends IRemoteConnection.Service {
/**
* Gets the remote system property indicated by the specified key. The connection must be open prior to calling this method.
*
* @param key
* the name of the property
* @return the string value of the property, or null if no property has that key
*/
public String getProperty(String key);
}
IRemoteConnectionProviderService.java 0000664 0000000 0000000 00000002355 12721140017 0040222 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core /*******************************************************************************
* Copyright (c) 2015 QNX Software Systems 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
*
* Contributors:
* QNX - initial API and implementation
*******************************************************************************/
package org.eclipse.remote.core;
/**
* A connection type service for connection types that have automatic means of adding
* and removing services. For example, the Local connection type needs to be able
* to ensure the Local connection is created, or adapters to other target management
* systems may prefer to let those systems manage the connections.
*
* @since 2.0
*/
public interface IRemoteConnectionProviderService extends IRemoteConnectionType.Service {
/**
* Initialize the service. Called after all existing connections are loaded.
* This method typically will add the initial connections or start up a job to do it.
* This method is called on startup, it's important that it be fast.
*/
void init();
}
IRemoteConnectionType.java 0000664 0000000 0000000 00000013223 12721140017 0036024 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core /*******************************************************************************
* Copyright (c) 2013 IBM Corporation 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
*
* Contributors:
* IBM Corporation - Initial API and implementation
*******************************************************************************/
package org.eclipse.remote.core;
import java.net.URI;
import java.util.List;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.remote.core.exception.RemoteConnectionException;
/**
* A remote connection type manages a list of connections that implement the same services.
* Services may be registered on the individual connections, or at the connection type level
* for service that apply to all connections of this type.
*
* @noimplement This interface is not intended to be implemented by clients.
* @since 2.0
*/
public interface IRemoteConnectionType {
/**
* The interface that is extend by services provided for this remote services implementation.
*
* @since 2.0
*/
interface Service {
IRemoteConnectionType getConnectionType();
interface Factory {
T getService(IRemoteConnectionType connectionType, Class service);
}
}
/**
* Get the remote services manager. This is a convenient way to get back
* to the root.
*
* @return remote services manager
*/
IRemoteServicesManager getRemoteServicesManager();
/**
* Get unique ID of this service. Can be used as a lookup key.
*
* @return unique ID
*/
String getId();
/**
* Get display name of this service.
*
* @return display name
*/
String getName();
/**
* Get the EFS scheme provided by this service.
*
* @return display name
*/
String getScheme();
/**
* Can you add new connections of this type using the API.
*
* @return can add
*/
boolean canAdd();
/**
* Can you edit connections of this type, i.e. create working copies.
*
* @return can edit
*/
boolean canEdit();
/**
* Can you remove connections of this type using the API.
*
* @return can remove
*/
boolean canRemove();
/**
* Get the service for this remote services implementation that implements the given interface.
*
* @param service
* the interface the required service must implements
* @return the desired service or null if there is no such service available
* @throws CoreException
* @since 2.0
*/
T getService(Class service);
/**
* Does this connection type support the given service.
*
* @param service
* the service to be tested
* @return true if this connection type supports this service
*/
boolean hasService(Class service);
/**
* Return the list of connection type services supported by this type.
*
* @return connection type services
*/
List getServices();
/**
* Do connections created by this connection type support the given service.
*
* @param service
* the service to be tested
* @return true if connections created by this connection type support this service
*/
boolean hasConnectionService(Class service);
/**
* Return the list of connection services supported by connections of this type.
*
* @return connection services
*/
List getConnectionServices();
/**
* Do processes created by this connection type support the given service.
*
* @param service
* the service to be tested
* @return true if processes created by this connection type support this service
*/
boolean hasProcessService(Class service);
/**
* Return the list of process services supported by connections of this type.
*
* @return process services
*/
List getProcessServices();
/**
* Gets the remote connection corresponding to the supplied name.
*
* @param name
* name of the connection (as returned by {@link IRemoteConnection#getName()})
* @return remote connection or null if no connection exists
*/
IRemoteConnection getConnection(String name);
/**
* Gets the remote connection corresponding to the supplied URI.
*
* @param uri
* URI containing a schema for this remote connection
* @return remote connection or null if no connection exists or the schema
* is incorrect
* @since 4.0
*/
IRemoteConnection getConnection(URI uri);
/**
* Get all the connections for this service provider.
*
* @return connections that we know about
*/
List getConnections();
/**
* Creates a new remote connection named with supplied name. The connection attributes will be the default for the
* implementation.
*
* Returns a working copy of the remote connection. Callers must call {@link IRemoteConnectionWorkingCopy#save()} before the
* connection can be used.
*
* @param name
* name of the connection
* @return a new connection working copy with the supplied name
* @throws RemoteConnectionException
* if connection creation failed
* @since 5.0
*/
IRemoteConnectionWorkingCopy newConnection(String name) throws RemoteConnectionException;
/**
* Remove a connection and all resources associated with it.
*
* @param connection
* connection to remove
* @throws RemoteConnectionException
* if the connection could not be removed
*/
void removeConnection(IRemoteConnection connection) throws RemoteConnectionException;
}
IRemoteConnectionWorkingCopy.java 0000664 0000000 0000000 00000004330 12721140017 0037355 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core /*******************************************************************************
* Copyright (c) 2007 IBM Corporation 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
*
* Contributors:
* IBM Corporation - Initial API and implementation
*******************************************************************************/
package org.eclipse.remote.core;
import org.eclipse.remote.core.exception.RemoteConnectionException;
/**
* A working copy of a remote connection used to change the name and/or
* attributes of the connection. It is also used when creating a new
* connection
*/
public interface IRemoteConnectionWorkingCopy extends IRemoteConnection {
/**
* Returns the original connection this working copy was created from.
* Returns null if this is a new connection.
*
* @return original connection
*/
public IRemoteConnection getOriginal();
/**
* Returns whether this connection has been modified since it was last saved or created.
*
* @return true if the connection has been modified
*/
public boolean isDirty();
/**
* Saves this working copy to its original connection and returns a handle to the resulting connection. Has no effect if this
* connection does not need saving.
*
* @return saved connection
* @throws RemoteConnectionException
*/
public IRemoteConnection save() throws RemoteConnectionException;
/**
* Set the name for this connection
*
* @param name
*/
public void setName(String name);
/**
* Set an implementation dependent attribute for the connection. Attributes keys supported by the connection can be obtained
* using {@link #getAttributes()}. Attributes are persisted along with connection information.
*
* @param key
* attribute key
* @param value
* attribute value
*/
public void setAttribute(String key, String value);
/**
* Set an attribute such as a password that's stored in secure storage.
*
* @param key
* @param value
* @since 2.0
*/
public void setSecureAttribute(String key, String value);
}
IRemoteFileService.java 0000664 0000000 0000000 00000005324 12721140017 0035266 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core /*******************************************************************************
* Copyright (c) 2007 IBM Corporation 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
*
* Contributors:
* IBM Corporation - Initial API and implementation
*******************************************************************************/
package org.eclipse.remote.core;
import java.net.URI;
import org.eclipse.core.filesystem.IFileStore;
import org.eclipse.core.runtime.IPath;
/**
* Interface for managing files on a remote system.
*
* @since 2.0
*/
public interface IRemoteFileService extends IRemoteConnection.Service {
/**
* Get the resource associated with path. IFileStore can then be used to
* perform operations on the file.
*
* The remote connection does not need to be open to use this method, but
* subsequent operations on the IFileStore that access the underlying remote
* filesystem may require the connection to be open.
*
* @param path
* path to resource
* @return the file store representing the remote path
*/
IFileStore getResource(String path);
/**
* Get the base directory to be used for relative paths.
*
* @return base directory
*/
String getBaseDirectory();
/**
* Set the base directory to be used for relative paths..
*
* @param path new base directory
*/
void setBaseDirectory(String path);
/**
* Gets the directory separator on the target system.
*
* @return String
*/
String getDirectorySeparator();
/**
* Convert URI to a remote path. This path is suitable for direct file
* operations on the remote system.
*
* The remote connection does not need to be open to use this method.
*
* @return IPath representing the remote path
*/
String toPath(URI uri);
/**
* Convert remote path to equivalent URI. This URI is suitable for EFS
* operations on the local system.
*
* The remote connection does not need to be open to use this method.
*
* @param path
* path on remote system
* @return URI representing path on remote system, or null if the path is
* invalid
*/
URI toURI(IPath path);
/**
* Convert string representation of a remote path to equivalent URI. This
* URI is suitable for EFS operations on the local system.
*
* The remote connection does not need to be open to use this method.
*
* @param path
* path on remote system
* @return URI representing path on remote system, or null if the path is
* invalid
*/
URI toURI(String path);
}
IRemotePortForwardingService.java 0000664 0000000 0000000 00000007420 12721140017 0037355 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core /*******************************************************************************
* Copyright (c) 2015 QNX Software Systems 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
*
* Contributors:
* QNX - initial API and implementation
*******************************************************************************/
package org.eclipse.remote.core;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.remote.core.exception.RemoteConnectionException;
/**
* A connection service for setting up port forwarding between the host and the remote.
* This is a feature provided by SSH.
*
* @since 2.0
*/
public interface IRemotePortForwardingService extends IRemoteConnection.Service {
/**
* Forward local port localPort to remote port fwdPort on remote machine fwdAddress. If this IRemoteConnection is not to
* fwdAddress, the port will be routed via the connection machine to fwdAddress.
*
* @param localPort
* local port to forward
* @param fwdAddress
* address of remote machine
* @param fwdPort
* remote port on remote machine
* @throws RemoteConnectionException
*/
public void forwardLocalPort(int localPort, String fwdAddress, int fwdPort) throws RemoteConnectionException;
/**
* Forward a local port to remote port fwdPort on remote machine fwdAddress. The local port is chosen dynamically and returned
* by the method. If this IRemoteConnection is not to fwdAddress, the port will be routed via the connection machine to
* fwdAddress.
*
* @param fwdAddress
* @param fwdPort
* @param monitor
* @return local port number
* @throws RemoteConnectionException
*/
public int forwardLocalPort(String fwdAddress, int fwdPort, IProgressMonitor monitor) throws RemoteConnectionException;
/**
* Forward remote port remotePort to port fwdPort on machine fwdAddress. When a connection is made to remotePort on the remote
* machine, it is forwarded via this IRemoteConnection to fwdPort on machine fwdAddress.
*
* @param remotePort
* remote port to forward
* @param fwdAddress
* address of recipient machine
* @param fwdPort
* port on recipient machine
* @throws RemoteConnectionException
*/
public void forwardRemotePort(int remotePort, String fwdAddress, int fwdPort) throws RemoteConnectionException;
/**
* Forward a remote port to port fwdPort on remote machine fwdAddress. The remote port is chosen dynamically and returned by the
* method. When a connection is made to this port on the remote machine, it is forwarded via this IRemoteConnection to fwdPort
* on machine fwdAddress.
*
* If fwdAddress is the empty string ("") then the fwdPort will be bound to any address on all interfaces. Note that this
* requires enabling the GatewayPort sshd option on some systems.
*
* @param fwdAddress
* @param fwdPort
* @param monitor
* @return remote port number
* @throws RemoteConnectionException
*/
public int forwardRemotePort(String fwdAddress, int fwdPort, IProgressMonitor monitor) throws RemoteConnectionException;
/**
* Remove the local port forwarding associated with the given port.
*
* @param port
* forwarded port
* @throws RemoteConnectionException
* @since 7.0
*/
public void removeLocalPortForwarding(int port) throws RemoteConnectionException;
/**
* Remove the remote port forwarding associated with the given port.
*
* @param port
* forwarded port
* @throws RemoteConnectionException
* @since 7.0
*/
public void removeRemotePortForwarding(int port) throws RemoteConnectionException;
}
IRemotePreferenceConstants.java 0000664 0000000 0000000 00000002004 12721140017 0037031 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core /*******************************************************************************
* Copyright (c) 2011 IBM Corporation 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
*
* Contributors:
* IBM Corporation - Initial API and implementation
*******************************************************************************/
package org.eclipse.remote.core;
/**
* Preference constants that can be used to check the default remote service provider preference.
*
* @since 6.0
*/
public interface IRemotePreferenceConstants {
/**
* Preference setting for the default connection type. Clients can check this preference to see if a default provider
* has been set, and if so, what the provider ID is.
*
* @since 2.0
*/
public static final String PREF_CONNECTION_TYPE_ID = "connectionTypeId"; //$NON-NLS-1$
}
IRemoteProcess.java 0000664 0000000 0000000 00000007746 12721140017 0034516 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core /*******************************************************************************
* Copyright (c) 2007 IBM Corporation 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
*
* Contributors:
* IBM Corporation - Initial API and implementation
*******************************************************************************/
package org.eclipse.remote.core;
import java.io.InputStream;
import java.io.OutputStream;
/**
* Represents a process running on a remote system. Remote process are created using the {@link IRemoteProcessBuilder} interface.
*/
public interface IRemoteProcess {
/**
* The interface that is extend by services provided for this remote connection.
*
* @since 2.0
*/
interface Service {
IRemoteProcess getRemoteProcess();
interface Factory {
T getService(IRemoteProcess remoteProcess, Class service);
}
}
/**
* Terminate the process
*/
void destroy();
/**
* Returns the exit value for the process
*
* @return the exit value
*/
int exitValue();
/**
* Gets the error output stream of the process
*
* Note: some implementations (e.g. JSch) will not work correctly if the remote process generates stdout or stderr but the
* calling thread does not read the corresponding output or error streams.
*
* @return the output stream connected to the standard
* error of the process
*/
InputStream getErrorStream();
/**
* Gets an InputStream which can be used to read the standard output stream of the process
*
* Note: some implementations (e.g. JSch) will not work correctly if the remote process generates stdout or stderr but the
* calling thread does not read the corresponding input or error streams.
*
* @return the input stream connected to the standard
* output of the process
*/
InputStream getInputStream();
/**
* Gets an output stream which can be used to write to the standard input stream of the process
*
* @return the output stream connected to the standard
* input of the process
*/
OutputStream getOutputStream();
/**
* Get the service for this remote process that implements the given interface.
*
* @param service
* the interface the required service must implements
* @return the desired service or null if there is no such service available
* @since 2.0
*/
T getService(Class service);
/**
* Does this remote process support the given service.
*
* @param service
* The service to be tested
* @return true if this connection supports the service
* @since 2.0
*/
boolean hasService(Class service);
/**
* Wait until the process has terminated
*
* Note: some implementations (e.g. JSch) will not work correctly if the remote process generates stdout or stderr but the
* calling thread does not read the corresponding input or error streams.
*
* @return the exit value of the process
* @throws InterruptedException
* if the current thread is
* interrupted by another thread while it is waiting
*/
int waitFor() throws InterruptedException;
/**
* Check if the remote process has completed.
*
* Note: some implementations (e.g. JSch) will not work correctly if the remote process generates stdout or stderr but the
* calling thread does not read the corresponding input or error streams.
*
* @return true if remote process has completed
*/
boolean isCompleted();
/**
* Get the connection that is used by this process
*
* @return connection used by this process
* @since 2.0
*/
IRemoteConnection getRemoteConnection();
/**
* Get the process builder used to create this process
*
* @return process builder used to create this process
* @since 2.0
*/
IRemoteProcessBuilder getProcessBuilder();
}
IRemoteProcessBuilder.java 0000664 0000000 0000000 00000010120 12721140017 0036001 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core /*******************************************************************************
* Copyright (c) 2007, 2010 IBM Corporation 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
*
* Contributors:
* IBM Corporation - Initial API and implementation
*******************************************************************************/
package org.eclipse.remote.core;
import java.io.IOException;
import java.util.List;
import java.util.Map;
import org.eclipse.core.filesystem.IFileStore;
/**
* Abstraction of a process builder for remote processes. This interface behaves in the same manner as
* {@link java.lang.ProcessBuilder}.
*/
public interface IRemoteProcessBuilder {
/**
* @since 5.0
*/
public static int NONE = 0x00;
/**
* Flag to request allocation of a pseudo-terminal for the process (RFC-4254
* Sec. 6.2)
*
* @since 5.0
*/
public static int ALLOCATE_PTY = 0x01;
/**
* Flag to request X11 forwarding (RFC-4254 Sec. 6.3)
*
* @since 5.0
*/
public static int FORWARD_X11 = 0x02;
/**
* Returns this process builder's operating system program and arguments.
*
* @return a list containing the program and arguments
*/
List command();
/**
* Sets this process builder's operating system program and arguments.
*
* @param command
* @return This process builder
*/
IRemoteProcessBuilder command(List command);
/**
* Sets this process builder's operating system program and arguments.
*
* @param command
* @return this process builder
*/
IRemoteProcessBuilder command(String... command);
/**
* Returns this process builder's working directory.
*
* @return an IFileStore reference to the working directory
*/
IFileStore directory();
/**
* Sets this process builder's working directory.
*
* @param directory
* @return This process builder
*/
IRemoteProcessBuilder directory(IFileStore directory);
/**
* Returns a string map view of this process builder's environment. The
* returned map behaves in the same manner as described in {@link java.lang.ProcessBuilder#environment()}.
*
* @return the process builder's environment
*/
Map environment();
/**
* Get the flags that are supported by this process builder.
*
* @return bitwise-or of the supported flags
* @since 5.0
*/
int getSupportedFlags();
/**
* Tells whether this process builder merges standard error and standard
* output.
*
* @return true if standard error and standard output will be merged
*/
boolean redirectErrorStream();
/**
* Sets this process builder's redirectErrorStream property.
*
* @param redirectErrorStream
* @return This process builder
*/
IRemoteProcessBuilder redirectErrorStream(boolean redirectErrorStream);
/**
* Starts a new process using the attributes of this process builder.
*
* @return remote process object
* @throws IOException
*/
IRemoteProcess start() throws IOException;
/**
* Starts a new process using the attributes of this process builder. The
* flags may be used to modify behavior of the remote process. These flags
* may only be supported by specific types of remote service providers.
* Clients can use {@link #getSupportedFlags()} to find out the flags
* supported by the service provider.
*
*
* Current flags are:
* NONE - disable any flags
* ALLOCATE_PTY - allocate a pseudo-terminal for the process (RFC-4254 Sec. 6.2)
* FORWARD_X11 - enable X11 forwarding (RFC-4254 Sec. 6.3)
*
*
* @param flags
* bitwise-or of flags to use when starting process
* @return remote process object
* @throws IOException
* @since 5.0
*/
IRemoteProcess start(int flags) throws IOException;
/**
* Get the connection that will be used by this process builder to create remote processes.
*
* @return connection used to create remote processes
* @since 2.0
*/
IRemoteConnection getRemoteConnection();
} IRemoteProcessControlService.java 0000664 0000000 0000000 00000004015 12721140017 0037362 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core /*******************************************************************************
* Copyright (c) 2015 QNX Software Systems 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
*
* Contributors:
* QNX - initial API and implementation
*******************************************************************************/
package org.eclipse.remote.core;
import java.io.InputStream;
import java.io.OutputStream;
/**
* A service to control and report on the state of a process.
*
* @since 2.0
*/
public interface IRemoteProcessControlService extends IRemoteProcess.Service {
/**
* Terminate the process
*/
public void destroy();
/**
* Returns the exit value for the process
*
* @return the exit value
*/
public int exitValue();
/**
* Gets the error output stream of the process
*
* @return the output stream connected to the standard
* error of the process
*/
public InputStream getErrorStream();
/**
* Gets an InputStream which can be used to read the standard output stream of the process
*
* @return the input stream connected to the standard
* output of the process
*/
public InputStream getInputStream();
/**
* Gets an output stream which can be used to write to the standard input stream of the process
*
* @return the output stream connected to the standard
* input of the process
*/
public OutputStream getOutputStream();
/**
* Wait until the process has terminated
*
* @return the exit value of the process
* @throws InterruptedException
* if the current thread is
* interrupted by another thread while it is waiting
*/
public int waitFor() throws InterruptedException;
/**
* Check if the remote process has completed
*
* @return true if remote process has completed
*/
public boolean isCompleted();
}
IRemoteProcessService.java 0000664 0000000 0000000 00000004757 12721140017 0036036 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core /*******************************************************************************
* Copyright (c) 2015 QNX Software Systems 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
*
* Contributors:
* QNX - initial API and implementation
*******************************************************************************/
package org.eclipse.remote.core;
import java.util.List;
import java.util.Map;
/**
* A connection service for starting up processes on a remote.
*
* @since 2.0
*/
public interface IRemoteProcessService extends IRemoteConnection.Service {
/**
* Returns an unmodifiable string map view of the remote environment. The connection must be open prior to calling this method.
*
* @return the remote environment
*/
public Map getEnv();
/**
* Returns the value of an environment variable. The connection must be open prior to calling this method.
*
* @param name
* name of the environment variable
* @return value of the environment variable or null if the variable is not defined
*/
public String getEnv(String name);
/**
* Get a process builder for creating remote processes
*
* @return process builder or null if connection is not open
*/
public IRemoteProcessBuilder getProcessBuilder(List command);
/**
* Get a process builder for creating remote processes
*
* @return process builder or null if connection is not open
*/
public IRemoteProcessBuilder getProcessBuilder(String... command);
/**
* Get the working directory. Relative paths will be resolved using this path.
*
* The remote connection does not need to be open to use this method, however a default directory path, rather than the actual
* working directory, may be returned in this case.
*
* @return String representing the current working directory
*/
public String getWorkingDirectory();
/**
* Set the working directory while the connection is open. The working directory will revert to the default when the connection
* is closed then subsequently reopened.
*
* Relative paths will be resolved using this path. The path must be valid and absolute for any changes to be made.
*
* @param path
* String representing the current working directory
* @since 4.0
*/
public void setWorkingDirectory(String path);
}
IRemoteProcessSignalService.java 0000664 0000000 0000000 00000003120 12721140017 0037153 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core /*******************************************************************************
* Copyright (c) 2015 IBM Corporation 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
*
* Contributors:
* IBM Corporation - Initial API and implementation
*******************************************************************************/
package org.eclipse.remote.core;
import org.eclipse.remote.core.exception.RemoteConnectionException;
/**
* A service abstraction for signals.
*
* @since 2.0
*/
public interface IRemoteProcessSignalService extends IRemoteProcess.Service {
public static final int HUP = 1;
public static final int INT = 2;
public static final int QUIT = 3;
public static final int ILL = 4;
public static final int ABRT = 6;
public static final int FPE = 8;
public static final int KILL = 9;
public static final int SEGV = 11;
public static final int PIPE = 13;
public static final int ALRM = 14;
public static final int TERM = 15;
public static final int STOP = 17;
public static final int TSTP = 18;
public static final int CONT = 19;
public static final int USR1 = 30;
public static final int USR2 = 31;
/**
* Send a signal to the remote process.
*
* @param signal
* signal to send.
* @throws RemoteConnectionException
* if the underlying connection fails
* @since 2.0
*/
void sendSignal(int signal) throws RemoteConnectionException;
}
IRemoteProcessTerminalService.java 0000664 0000000 0000000 00000002410 12721140017 0037512 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core /*******************************************************************************
* Copyright (c) 2015 IBM Corporation 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
*
* Contributors:
* IBM Corporation - Initial API and implementation
*******************************************************************************/
package org.eclipse.remote.core;
/**
* A service abstraction for remote terminals.
*
* @since 2.0
*/
public interface IRemoteProcessTerminalService extends IRemoteProcess.Service {
/**
* Change the terminal window dimension interactively. Refer to RFC 4254 6.7. Window Dimension Change Message. The character/row
* dimensions override the pixel dimensions (when nonzero). Pixel dimensions refer to the drawable area of the window.
*
* @param cols
* terminal width in characters
* @param rows
* terminal height in characters
* @param width
* terminal width in pixels
* @param height
* terminal height in pixels
*/
void setTerminalSize(int cols, int rows, int width, int height);
}
IRemoteResource.java 0000664 0000000 0000000 00000005023 12721140017 0034651 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core /*******************************************************************************
* Copyright (c) 2011 IBM 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:
* IBM - Initial API and implementation
*******************************************************************************/
package org.eclipse.remote.core;
import java.net.URI;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
/**
* Abstraction of a remote resource. There are currently two types of remote resources: fully remote and synchronized. This
* interface provides a common mechanism for accessing resource information from either type.
*
* Usage:
*
*
* IRemoteResource remoteRes = (IRemoteResource)resource.getAdapter(IRemoteResource.class);
* if (remoteRes != null) {
* URI location = remoteRes.getDefaultLocationURI();
* ...
* }
*
*
* @author greg
* @since 6.0
*
*/
public interface IRemoteResource {
/**
* Get the active location URI of the resource in the remote project. Returns null if the URI can't be obtained (@see
* {@link IResource#getLocationURI()}).
*
* For fully remote projects, this is just the URI of the remote resource. For synchronized projects, this is the URI of the
* resource from the active synchronization target.
*
* @return URI or null if URI can't be obtained
*/
public URI getActiveLocationURI();
/**
* Get the platform resource corresponding to the remote resource
*
* @return IResource
*/
public IResource getResource();
/**
* Synchronize the resource with the underlying filesystem. Performs a refresh for local and remote projects, but causes
* synchronized projects to attempt to synchronize with their remote files. May synchronize more than just the single resource.
* Blocks until the refresh has completed, so callers should use a job if necessary.
*
* @param monitor
* progress monitor to cancel refresh
* @throws CoreException
* if the underlying synchronization fails
*/
public void refresh(IProgressMonitor monitor) throws CoreException;
/**
* Set the platform resource
*
* @param resource
* platform resource corresponding to this remote resource
*/
public void setResource(IResource resource);
} IRemoteServicesManager.java 0000664 0000000 0000000 00000010016 12721140017 0036136 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core /*******************************************************************************
* Copyright (c) 2015 QNX Software Systems 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
*
* Contributors:
* QNX - initial API and implementation
*******************************************************************************/
package org.eclipse.remote.core;
import java.net.URI;
import java.util.List;
/**
* The main entry point into the remote services system. The remote services manager
* is an OSGi service. It provides a list of connection types and the global
* list of all connections.
*
* @noimplement This interface is not intended to be implemented by clients.
* @since 2.0
*/
public interface IRemoteServicesManager {
/**
* Get the connection type identified by the id
*
* @param id
* id of the connection type
* @return connection type or null if the service can not be found
*/
IRemoteConnectionType getConnectionType(String id);
/**
* Get the connection type that provides connections to locations identified by
* the URI.
*
* @param uri
* uri of locations to be accessed
* @return the connection type that can be used to access the locations
* or null if no connection type is available for the uri.
*/
IRemoteConnectionType getConnectionType(URI uri);
/**
* Return the connection type used to access local resources.
*
* @return the local services
*/
IRemoteConnectionType getLocalConnectionType();
/**
* Returns the list of all connection types including the local services.
*
* @return all connection types
*/
List getAllConnectionTypes();
/**
* Returns the list of all connection types that support connections that provide specific services. The connections
* can provide additional services that are not included in the list, so this just guarantees the minimum set of services that
* will be supported.
*
* @param services
* services provided by connections supported by this connection type
* @return compatible connection types
*/
@SuppressWarnings("unchecked")
List getConnectionTypesSupporting(Class... services);
/**
* Returns the list of all connection types that provide specific services. The connection types can provide additional services
* that are not included in the list, so this just guarantees the minimum set of services that will be supported.
*
* @param services
* services provided by this connection type
* @return compatible connection types
*/
@SuppressWarnings("unchecked")
List getConnectionTypesByService(Class... services);
/**
* Returns the list of connection types except for the local connection type.
*
* @return all connection types that are really remote
*/
List getRemoteConnectionTypes();
/**
* Returns the list of all known remote connections.
*
* @return all remote connections
*/
List getAllRemoteConnections();
/**
* Add a global connection change listener that receives events for all connections.
*
* @param listener
* global connection change listener to be added
*/
void addRemoteConnectionChangeListener(IRemoteConnectionChangeListener listener);
/**
* Remove the global connection change listener.
*
* @param listener
* global connection change listener to be removed
*/
void removeRemoteConnectionChangeListener(IRemoteConnectionChangeListener listener);
/**
* Used by connections and other components to notify the global connection
* change listeners of events.
*
* @param event
* connection change event
*/
void fireRemoteConnectionChangeEvent(RemoteConnectionChangeEvent event);
}
IUserAuthenticatorService.java 0000664 0000000 0000000 00000010474 12721140017 0036706 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core /*******************************************************************************
* Copyright (c) 2000, 2007, 2013 IBM Corporation 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
*
* Contributors:
* IBM Corporation - initial API and implementation
* Atsuhiko Yamanaka, JCraft,Inc. - adding promptForKeyboradInteractive method
* - copying this class from cvs.core plug-in.
* Greg Watson, IBM - modified for use with PTP
*******************************************************************************/
package org.eclipse.remote.core;
import java.net.PasswordAuthentication;
/**
* Allow clients to provide their own user interface for connection authentication.
*
* @since 2.0
*/
public interface IUserAuthenticatorService extends IRemoteConnection.Service {
/**
* ID for an "Ok" response (value 0).
*/
public final static int OK = 0;
/**
* ID for a "Cancel" response (value 1).
*/
public final static int CANCEL = 1;
/**
* ID for a "Yes" response (value 2).
*/
public final static int YES = 2;
/**
* ID for a "No" response (value 3).
*/
public final static int NO = 3;
/**
* Constant for a prompt with no type (value 0).
*/
public final static int NONE = 0;
/**
* Constant for an error prompt (value 1).
*/
public final static int ERROR = 1;
/**
* Constant for an information prompt (value 2).
*/
public final static int INFORMATION = 2;
/**
* Constant for a question prompt (value 3).
*/
public final static int QUESTION = 3;
/**
* Constant for a warning dialog (value 4).
*/
public final static int WARNING = 4;
/**
* Authenticates the user for access.
* The obtained values for user name and password will be placed
* into returned object. Implementors are allowed to
* save user names and passwords. The user should be prompted for
* user name and password if there is no saved one.
*
* @param username
* The initial username, or null if there is no initial username
* @param message
* An optional message to display if, e.g., previous authentication failed.
*/
public PasswordAuthentication prompt(String username, String message);
/**
* Prompts the user for a number values using text fields. The labels are provided in
* the prompt array. Implementors will return the entered values, or null if
* the user cancels the prompt.
*
* @param destination
* the destination in the format like username@hostname:port
* @param name
* a name for this dialog
* @param message
* the message to be displayed to the user
* @param prompt
* labels for each of the text fields.
* @param echo
* an array to show which fields are secret
* @return the entered values, or null if the user canceled.
*/
public String[] prompt(String destination, String name, String message, String[] prompt, boolean[] echo);
/**
* Prompts for additional information regarding this authentication
* request. A default implementation of this method should return the defaultResponse,
* whereas alternate implementations could prompt the user with a dialog.
*
* @param promptType
* one of the following values:
*
*
NONE for a unspecified prompt type
*
ERROR for an error prompt
*
INFORMATION for an information prompt
*
QUESTION for a question prompt
*
WARNING for a warning prompt
*
* @param title
* the prompt title that could be displayed to the user
* @param message
* the message to display to the user
* @param promptResponses
* the possible responses to the prompt (e.g. corresponding to buttons on a dialog)
* @param defaultResponseIndex
* the default response to the prompt
* @return the response to the prompt
*/
public int prompt(int promptType, String title, String message, int[] promptResponses, int defaultResponseIndex);
}
RemoteConnectionChangeEvent.java 0000664 0000000 0000000 00000004563 12721140017 0037170 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core /*******************************************************************************
* Copyright (c) 2008 IBM Corporation 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
*
* Contributors:
* IBM Corporation - Initial API and implementation
*******************************************************************************/
package org.eclipse.remote.core;
/**
* Event representing a change in connection status. The {@link #getType()} method can be used to obtain information about the type
* of event that occurred.
*
* @since 2.0
*/
public class RemoteConnectionChangeEvent {
/**
* Event indicating that the connection was closed.
*/
public static final int CONNECTION_CLOSED = 1 << 0;
/**
* Event indicating that the connection was opened.
*/
public static final int CONNECTION_OPENED = 1 << 1;
/**
* Event indicating that the connection was closed abnormally.
*/
public static final int CONNECTION_ABORTED = 1 << 2;
/**
* Event indicating that the connection name will be changed. It is sent prior to the name change taking place.
* The event passes an IRemoteConnectionWorkingCopy so that the original and new name can be used by the listener.
*/
public static final int CONNECTION_RENAMED = 1 << 3;
/**
* Event indicating the connection was added.
* @since 2.0
*/
public static final int CONNECTION_ADDED = 1 << 4;
/**
* Event indicating the connection is about to be removed.
* @since 2.0
*/
public static final int CONNECTION_REMOVED = 1 << 5;
private final IRemoteConnection connection;
private final int type;
public RemoteConnectionChangeEvent(IRemoteConnection connection, int type) {
this.connection = connection;
this.type = type;
}
/**
* Get the connection that has changed.
*
* @return IRemoteConnection
*/
public IRemoteConnection getConnection() {
return connection;
}
/**
* Returns the type of event being reported. This type
* is obtained by bitwise OR'ing the event types together.
*
* {@link #CONNECTION_CLOSED} {@link #CONNECTION_OPENED} {@link #CONNECTION_ABORTED} {@link #CONNECTION_RENAMED}
*
* @return a bitwise OR of event type constants
*/
public int getType() {
return type;
}
}
RemoteConnectionPropertyTester.java 0000664 0000000 0000000 00000002114 12721140017 0040002 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core /*******************************************************************************
* Copyright (c) 2016 QNX Software Systems, 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
*
* Contributors:
* QNX Software Systems - initial contribution
*******************************************************************************/
package org.eclipse.remote.core;
import org.eclipse.core.expressions.PropertyTester;
/**
* @since 2.1
*/
public class RemoteConnectionPropertyTester extends PropertyTester {
@Override
public boolean test(Object receiver, String property, Object[] args, Object expectedValue) {
if (receiver instanceof IRemoteConnection) {
if (property.equals("isConnectionType")) {
IRemoteConnection connection = (IRemoteConnection) receiver;
if (connection.getConnectionType().getId().equals(expectedValue)) {
return true;
}
}
}
return false;
}
}
RemoteProcessAdapter.java 0000664 0000000 0000000 00000003473 12721140017 0035677 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core /*******************************************************************************
* Copyright (c) 2009 IBM Corporation 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
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.remote.core;
import java.io.InputStream;
import java.io.OutputStream;
/**
* Utility class to adapt an IRemoteProcess to a java.lang.Process
*
* @author crecoskie
*
*/
public class RemoteProcessAdapter extends Process {
private final IRemoteProcess fProcess;
public RemoteProcessAdapter(IRemoteProcess process) {
fProcess = process;
}
/*
* (non-Javadoc)
*
* @see java.lang.Process#destroy()
*/
@Override
public void destroy() {
fProcess.destroy();
}
/*
* (non-Javadoc)
*
* @see java.lang.Process#exitValue()
*/
@Override
public int exitValue() {
return fProcess.exitValue();
}
/*
* (non-Javadoc)
*
* @see java.lang.Process#getErrorStream()
*/
@Override
public InputStream getErrorStream() {
return fProcess.getErrorStream();
}
/*
* (non-Javadoc)
*
* @see java.lang.Process#getInputStream()
*/
@Override
public InputStream getInputStream() {
return fProcess.getInputStream();
}
/*
* (non-Javadoc)
*
* @see java.lang.Process#getOutputStream()
*/
@Override
public OutputStream getOutputStream() {
return fProcess.getOutputStream();
}
/*
* (non-Javadoc)
*
* @see java.lang.Process#waitFor()
*/
@Override
public int waitFor() throws InterruptedException {
return fProcess.waitFor();
}
}
RemoteServicesUtils.java 0000664 0000000 0000000 00000007744 12721140017 0035571 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core /*******************************************************************************
* Copyright (c) 2013, 2015 IBM Corporation 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
*
* Contributors:
* IBM Corporation - Initial API and implementation
* Martin Oberhuber - [468889] Support Eclipse older than Mars
*******************************************************************************/
package org.eclipse.remote.core;
import java.net.URI;
import java.net.URISyntaxException;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.remote.internal.core.RemoteCorePlugin;
import org.eclipse.remote.internal.core.RemotePath;
import org.eclipse.remote.internal.core.preferences.Preferences;
/**
* Remote services utility methods.
*/
public class RemoteServicesUtils {
/**
* Constructs a new POSIX path from the given string path. The string path
* must represent a valid file system path on a POSIX file system. The path
* is canonicalized and double slashes are removed except at the beginning
* (to handle UNC paths). All forward slashes ('/') are treated as segment
* delimiters. This factory method should be used if the string path is for
* a POSIX file system.
*
* @param path the string path
* @see org.eclipse.core.runtime.Path#forPosix(String)
* @since 2.0
*/
public static IPath posixPath(String path) {
try {
//Use the Mars implementation of Path, see bug 454959
return Path.forPosix(path);
} catch (NoSuchMethodError e) {
//TODO For older Eclipse, use the fallback below. That code should be
//removed when support for Eclipse older than Mars is no longer needed.
return RemotePath.forPosix(path);
}
}
/**
* Convert a UNC path to a URI
*
* Maps the UNC server component to a connection known by one of the remote service implementations. It is assumed that the
* server component is of the form "[connection_type_id:]connection_name". If the "connection_type_id:" part is omitted then the
* current connection type preference is used by default. If no preference is set, then each implementation is tried until
* a matching connection name is found.
*
* @param path
* UNC path
* @return corresponding URI or null if not a valid path
*/
public static URI toURI(IPath path) {
if (path.isUNC()) {
IRemoteServicesManager manager = RemoteCorePlugin.getService(IRemoteServicesManager.class);
/*
* Split the server component if possible.
*/
String[] parts = path.segment(0).split(":"); //$NON-NLS-1$
IRemoteConnectionType services = null;
String connName = null;
if (parts.length == 2) {
services = manager.getConnectionType(parts[0]);
connName = parts[1];
} else if (parts.length == 1) {
String id = Preferences.getString(IRemotePreferenceConstants.PREF_CONNECTION_TYPE_ID);
if (id != null) {
services = manager.getConnectionType(id);
}
connName = parts[0];
}
/*
* If we've found the remote services then look up the connection, otherwise iterate through all available services
* checking for the connection name.
*/
IRemoteConnection conn = null;
if (services != null) {
conn = services.getConnection(connName);
} else if (connName != null) {
for (IRemoteConnectionType s : manager.getAllConnectionTypes()) {
if (s != null) {
conn = s.getConnection(connName);
if (conn != null) {
break;
}
}
}
}
/*
* If a connection was found then convert it to a URI.
*/
if (conn != null) {
String scheme = conn.getConnectionType().getScheme();
String filePath = path.removeFirstSegments(1).makeAbsolute().toString();
try {
return new URI(scheme, connName, filePath, null, null);
} catch (URISyntaxException e) {
// Ignore
}
}
}
return null;
}
}
org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core/exception/ 0000775 0000000 0000000 00000000000 12721140017 0033007 5 ustar 00root root 0000000 0000000 AddressInUseException.java 0000664 0000000 0000000 00000002152 12721140017 0040003 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core/exception /*******************************************************************************
* Copyright (c) 2007 IBM Corporation 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
*
* Contributors:
* IBM Corporation - Initial API and implementation
*******************************************************************************/
package org.eclipse.remote.core.exception;
/**
* Exception thrown when a connection address is already in use.
*
*/
public class AddressInUseException extends RemoteConnectionException {
private static final long serialVersionUID = 1771839754428411610L;
/**
* @param message
* @param cause
*/
public AddressInUseException(String message, Throwable cause) {
super(message, cause);
}
/**
* @param message
*/
public AddressInUseException(String message) {
super(message);
}
/**
* @param cause
*/
public AddressInUseException(Throwable cause) {
super(cause);
}
}
ConnectionExistsException.java 0000664 0000000 0000000 00000001744 12721140017 0040757 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core/exception /*******************************************************************************
* Copyright (c) 2015 QNX Software Systems 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
*
* Contributors:
* QNX - initial API and implementation
*******************************************************************************/
package org.eclipse.remote.core.exception;
/**
* Thrown when trying to add a connection with the same name as an existing
* connection, or when trying to rename a connection to the same name as an
* existing connection.
*
* @since 2.0
*/
public class ConnectionExistsException extends RemoteConnectionException {
private static final long serialVersionUID = -1591235868439783613L;
public ConnectionExistsException(String message) {
super(message);
}
}
PrivilegedPortException.java 0000664 0000000 0000000 00000002164 12721140017 0040414 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core/exception /*******************************************************************************
* Copyright (c) 2007 IBM Corporation 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
*
* Contributors:
* IBM Corporation - Initial API and implementation
*******************************************************************************/
package org.eclipse.remote.core.exception;
/**
* Exception thrown when an attempt is made to use a privileged port.
*/
public class PrivilegedPortException extends RemoteConnectionException {
private static final long serialVersionUID = -7794871221470179956L;
/**
* @param message
* @param cause
*/
public PrivilegedPortException(String message, Throwable cause) {
super(message, cause);
}
/**
* @param message
*/
public PrivilegedPortException(String message) {
super(message);
}
/**
* @param cause
*/
public PrivilegedPortException(Throwable cause) {
super(cause);
}
}
RemoteConnectionException.java 0000664 0000000 0000000 00000002572 12721140017 0040733 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core/exception /*******************************************************************************
* Copyright (c) 2007 IBM Corporation 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
*
* Contributors:
* IBM Corporation - Initial API and implementation
*******************************************************************************/
package org.eclipse.remote.core.exception;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.remote.internal.core.RemoteCorePlugin;
/**
* Exception thrown when a remote connection error occurs.
*/
public class RemoteConnectionException extends CoreException {
private static final long serialVersionUID = -7794871221470179956L;
/**
* @param message
* @param cause
*/
public RemoteConnectionException(String message, Throwable cause) {
super(new Status(IStatus.ERROR, RemoteCorePlugin.getUniqueIdentifier(), message, cause));
}
/**
* @param message
*/
public RemoteConnectionException(String message) {
this(message, null);
}
/**
* @param cause
*/
public RemoteConnectionException(Throwable cause) {
this(cause.getMessage(), cause);
}
}
UnableToForwardPortException.java 0000664 0000000 0000000 00000002214 12721140017 0041354 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core/exception /*******************************************************************************
* Copyright (c) 2007 IBM Corporation 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
*
* Contributors:
* IBM Corporation - Initial API and implementation
*******************************************************************************/
package org.eclipse.remote.core.exception;
/**
* Exception thrown when a port is unable to be forwarded.
*/
public class UnableToForwardPortException extends RemoteConnectionException {
/**
*
*/
private static final long serialVersionUID = -5814772755700213717L;
/**
* @param message
* @param cause
*/
public UnableToForwardPortException(String message, Throwable cause) {
super(message, cause);
}
/**
* @param message
*/
public UnableToForwardPortException(String message) {
super(message);
}
/**
* @param cause
*/
public UnableToForwardPortException(Throwable cause) {
super(cause);
}
}
org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core/launch/ 0000775 0000000 0000000 00000000000 12721140017 0032263 5 ustar 00root root 0000000 0000000 IRemoteLaunchConfigService.java 0000664 0000000 0000000 00000003650 12721140017 0040221 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/core/launch /*******************************************************************************
* Copyright (c) 2015 QNX Software Systems 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
*
* Contributors:
* QNX - initial API and implementation
*******************************************************************************/
package org.eclipse.remote.core.launch;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationType;
import org.eclipse.remote.core.IRemoteConnection;
/**
* Manages and persists the mapping between launch configurations and
* remote connections that they run on. Each launch configuration has an
* active remote connection.
*
* @since 2.0
*/
public interface IRemoteLaunchConfigService {
/**
* Sets the active remote connection for the given launch configuration.
*
* @param launchConfig launch configuration
* @param connection active remote connection
*/
void setActiveConnection(ILaunchConfiguration launchConfig, IRemoteConnection connection);
/**
* Gets the active remote connection for the given launch configuration
* @param launchConfig launch configuration
* @return active remote connection
*/
IRemoteConnection getActiveConnection(ILaunchConfiguration launchConfig);
/**
* For a given launch configuration type, get the remote connection that was last
* used by a launch configuration of that type.
*
* This is used for new launch configurations with the assumption that the user
* will want to use the same remote connection.
*
* @param launchConfigType launch configuration type
* @return last active remote configuration
*/
IRemoteConnection getLastActiveConnection(ILaunchConfigurationType launchConfigType);
}
org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/ 0000775 0000000 0000000 00000000000 12721140017 0031675 5 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core/ 0000775 0000000 0000000 00000000000 12721140017 0032625 5 ustar 00root root 0000000 0000000 RemoteConnection.java 0000664 0000000 0000000 00000017656 12721140017 0036703 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core /*******************************************************************************
* Copyright (c) 2015 QNX Software Systems 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
*
* Contributors:
* QNX - initial API and implementation
*******************************************************************************/
package org.eclipse.remote.internal.core;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.Map;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.core.runtime.ListenerList;
import org.eclipse.equinox.security.storage.ISecurePreferences;
import org.eclipse.equinox.security.storage.StorageException;
import org.eclipse.remote.core.IRemoteConnection;
import org.eclipse.remote.core.IRemoteConnectionChangeListener;
import org.eclipse.remote.core.IRemoteConnectionControlService;
import org.eclipse.remote.core.IRemoteConnectionPropertyService;
import org.eclipse.remote.core.IRemoteConnectionType;
import org.eclipse.remote.core.IRemoteConnectionWorkingCopy;
import org.eclipse.remote.core.RemoteConnectionChangeEvent;
import org.eclipse.remote.core.exception.ConnectionExistsException;
import org.eclipse.remote.core.exception.RemoteConnectionException;
import org.osgi.service.prefs.BackingStoreException;
import org.osgi.service.prefs.Preferences;
/**
* The standard root class for remote connections. Implements common hook up
* with the remote services and the remote services manager as well as handling
* for services.
*/
public class RemoteConnection implements IRemoteConnection {
private final RemoteConnectionType connectionType;
private String name;
private final Map, Service> servicesMap = new HashMap<>();
private final ListenerList fListeners = new ListenerList();
final static String EMPTY_STRING = ""; //$NON-NLS-1$
public RemoteConnection(RemoteConnectionType connectionType, String name) {
this.connectionType = connectionType;
this.name = name;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnection#getConnectionType()
*/
@Override
public IRemoteConnectionType getConnectionType() {
return connectionType;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnection#getService(java.lang.Class)
*/
@SuppressWarnings("unchecked")
@Override
public T getService(Class service) {
T obj = (T) servicesMap.get(service);
if (obj == null) {
obj = connectionType.getConnectionService(this, service);
if (obj != null) {
servicesMap.put(service, obj);
}
}
return obj;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnection#hasService(java.lang.Class)
*/
@Override
public boolean hasService(Class service) {
return servicesMap.get(service.getName()) != null || connectionType.hasConnectionService(service);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnection#getName()
*/
@Override
public String getName() {
return name;
}
/**
* Called from working copy when name has changed.
*
* @param name
* the new name
*/
void rename(String newName) throws ConnectionExistsException {
try {
// Copy the old preferences over and remove the old node
if (connectionType.getPreferenceNode().nodeExists(newName)) {
throw new ConnectionExistsException(newName);
}
Preferences newPrefs = connectionType.getPreferenceNode().node(URLEncoder.encode(newName, "UTF-8"));
Preferences oldPrefs = getPreferences();
for (String key : oldPrefs.keys()) {
newPrefs.put(key, oldPrefs.get(key, null));
}
oldPrefs.removeNode();
} catch (BackingStoreException | UnsupportedEncodingException e) {
RemoteCorePlugin.log(e);
}
this.name = newName;
}
Preferences getPreferences() {
try {
return connectionType.getPreferenceNode().node(URLEncoder.encode(name, "UTF-8")); //$NON-NLS-1$
} catch (UnsupportedEncodingException e) {
// Should not happen!
throw new RuntimeException(e);
}
}
ISecurePreferences getSecurePreferences() {
try {
return connectionType.getSecurePreferencesNode().node(URLEncoder.encode(name, "UTF-8")); //$NON-NLS-1$
} catch (UnsupportedEncodingException e) {
// Should not happen!
throw new RuntimeException(e);
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnection#getAttribute(java.lang.String)
*/
@Override
public String getAttribute(String key) {
return getPreferences().get(key, EMPTY_STRING);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnection#getSecureAttribute(java.lang.String)
*/
@Override
public String getSecureAttribute(String key) {
try {
return getSecurePreferences().get(key, EMPTY_STRING);
} catch (StorageException e) {
RemoteCorePlugin.log(e);
return EMPTY_STRING;
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnection#getWorkingCopy()
*/
@Override
public IRemoteConnectionWorkingCopy getWorkingCopy() {
return new RemoteConnectionWorkingCopy(this);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnection#getProperty(java.lang.String)
*/
@Override
public String getProperty(String key) {
IRemoteConnectionPropertyService propertyService = getService(IRemoteConnectionPropertyService.class);
if (propertyService != null) {
return propertyService.getProperty(key);
} else {
return null;
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnection#open(org.eclipse.core.runtime.IProgressMonitor)
*/
@Override
public void open(IProgressMonitor monitor) throws RemoteConnectionException {
IRemoteConnectionControlService controlService = getService(IRemoteConnectionControlService.class);
if (controlService != null) {
controlService.open(monitor);
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnection#close()
*/
@Override
public void close() {
IRemoteConnectionControlService controlService = getService(IRemoteConnectionControlService.class);
if (controlService != null) {
controlService.close();
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnection#isOpen()
*/
@Override
public boolean isOpen() {
IRemoteConnectionControlService controlService = getService(IRemoteConnectionControlService.class);
if (controlService != null) {
return controlService.isOpen();
} else {
// default is always open
return true;
}
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.remote.core.IRemoteConnection#addConnectionChangeListener(org.eclipse.remote.core.IRemoteConnectionChangeListener
* )
*/
@Override
public void addConnectionChangeListener(IRemoteConnectionChangeListener listener) {
fListeners.add(listener);
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.remote.core.IRemoteConnection#removeConnectionChangeListener(org.eclipse.remote.core.
* IRemoteConnectionChangeListener
* )
*/
@Override
public void removeConnectionChangeListener(IRemoteConnectionChangeListener listener) {
fListeners.remove(listener);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnection#fireConnectionChangeEvent(int)
*/
@Override
public void fireConnectionChangeEvent(final int type) {
RemoteConnectionChangeEvent event = new RemoteConnectionChangeEvent(this, type);
for (Object listener : fListeners.getListeners()) {
((IRemoteConnectionChangeListener) listener).connectionChanged(event);
}
// fire to the global listeners too
connectionType.getRemoteServicesManager().fireRemoteConnectionChangeEvent(event);
}
/*
* (non-Javadoc)
*
* @see java.lang.Object#toString()
*/
@Override
public String toString() {
return name + " - " + connectionType.getName(); //$NON-NLS-1$
}
}
RemoteConnectionType.java 0000664 0000000 0000000 00000027632 12721140017 0037540 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core /*******************************************************************************
* Copyright (c) 2015 QNX Software Systems 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
*
* Contributors:
* QNX - initial API and implementation
*******************************************************************************/
package org.eclipse.remote.internal.core;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URLDecoder;
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.IConfigurationElement;
import org.eclipse.equinox.security.storage.ISecurePreferences;
import org.eclipse.remote.core.IRemoteConnection;
import org.eclipse.remote.core.IRemoteConnectionType;
import org.eclipse.remote.core.IRemoteConnectionWorkingCopy;
import org.eclipse.remote.core.IRemoteProcess;
import org.eclipse.remote.core.IRemoteServicesManager;
import org.eclipse.remote.core.RemoteConnectionChangeEvent;
import org.eclipse.remote.core.exception.ConnectionExistsException;
import org.eclipse.remote.core.exception.RemoteConnectionException;
import org.osgi.service.prefs.BackingStoreException;
import org.osgi.service.prefs.Preferences;
/**
* The implementation for a given remote services collection.n
*/
public class RemoteConnectionType implements IRemoteConnectionType {
private final RemoteServicesManager remoteServicesManager;
private final String id;
private final String name;
private final String scheme;
private final boolean canAdd;
private final boolean canEdit;
private final boolean canRemove;
private final Map, Object> serviceMap = new HashMap<>();
private final Map serviceDefinitionMap = new HashMap<>();
private final Map connectionServiceDefinitionMap = new HashMap<>();
private final Map processServiceDefinitionMap = new HashMap<>();
private final Map connections = new HashMap<>();
public RemoteConnectionType(IConfigurationElement ce, RemoteServicesManager manager) {
this.remoteServicesManager = manager;
id = ce.getAttribute("id"); //$NON-NLS-1$
name = ce.getAttribute("name"); //$NON-NLS-1$
scheme = ce.getAttribute("scheme"); //$NON-NLS-1$
// capabilities, default is true for all of these
String canAddStr = ce.getAttribute("canAdd"); //$NON-NLS-1$
canAdd = canAddStr != null ? Boolean.parseBoolean(canAddStr) : true;
String canEditStr = ce.getAttribute("canEdit"); //$NON-NLS-1$
canEdit = canEditStr != null ? Boolean.parseBoolean(canEditStr) : true;
String canRemoveStr = ce.getAttribute("canRemove"); //$NON-NLS-1$
canRemove = canRemoveStr != null ? Boolean.parseBoolean(canRemoveStr) : true;
// load up existing connections
try {
for (String nodeName : getPreferenceNode().childrenNames()) {
String connectionName = URLDecoder.decode(nodeName, "UTF-8");
connections.put(connectionName, new RemoteConnection(this, connectionName));
}
} catch (BackingStoreException | UnsupportedEncodingException e) {
RemoteCorePlugin.log(e);
}
}
Preferences getPreferenceNode() {
return remoteServicesManager.getPreferenceNode().node(id);
}
ISecurePreferences getSecurePreferencesNode() {
return remoteServicesManager.getSecurePreferenceNode().node(id);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnectionType#getRemoteServicesManager()
*/
@Override
public IRemoteServicesManager getRemoteServicesManager() {
return remoteServicesManager;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnectionType#getId()
*/
@Override
public String getId() {
return id;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnectionType#getName()
*/
@Override
public String getName() {
return name;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnectionType#getScheme()
*/
@Override
public String getScheme() {
return scheme;
}
@Override
public boolean canAdd() {
return canAdd;
}
@Override
public boolean canEdit() {
return canEdit;
}
@Override
public boolean canRemove() {
return canRemove;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnectionType#getService(java.lang.Class)
*/
@Override
public T getService(Class service) {
@SuppressWarnings("unchecked")
T obj = (T) serviceMap.get(service);
if (obj == null) {
IConfigurationElement ce = serviceDefinitionMap.get(service.getName());
if (ce != null) {
try {
Service.Factory factory = (Service.Factory) ce.createExecutableExtension("factory"); //$NON-NLS-1$
if (factory != null) {
obj = factory.getService(this, service);
serviceMap.put(service, obj);
}
} catch (CoreException e) {
RemoteCorePlugin.log(e.getStatus());
}
}
}
return obj;
}
@Override
public List getServices() {
return new ArrayList<>(serviceDefinitionMap.keySet());
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnectionType#hasService(java.lang.Class)
*/
@Override
public boolean hasService(Class service) {
return serviceDefinitionMap.get(service.getName()) != null;
}
/**
* Called from the connection to get a service object for that connection.
*
* @param connection
* the connection to which the service applies
* @param service
* the interface the service must implement
* @return the service object
* @throws CoreException
*/
public T getConnectionService(IRemoteConnection connection, Class service) {
IConfigurationElement ce = connectionServiceDefinitionMap.get(service.getName());
if (ce != null) {
try {
IRemoteConnection.Service.Factory factory = (IRemoteConnection.Service.Factory) ce
.createExecutableExtension("factory"); //$NON-NLS-1$
if (factory != null) {
return factory.getService(connection, service);
}
} catch (CoreException e) {
RemoteCorePlugin.log(e.getStatus());
}
}
return null;
}
@Override
public List getConnectionServices() {
return new ArrayList<>(connectionServiceDefinitionMap.keySet());
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnectionType#hasConnectionService(java.lang.Class)
*/
@Override
public boolean hasConnectionService(Class service) {
return connectionServiceDefinitionMap.get(service.getName()) != null;
}
/**
* Called from the remote process to get a service object for that process.
*
* @param process
* the process to which the service applies
* @param service
* the interface the service must implement
* @return the service object
* @throws CoreException
*/
public T getProcessService(IRemoteProcess process, Class service) {
IConfigurationElement ce = processServiceDefinitionMap.get(service.getName());
if (ce != null) {
try {
IRemoteProcess.Service.Factory factory = (IRemoteProcess.Service.Factory) ce.createExecutableExtension("factory"); //$NON-NLS-1$
if (factory != null) {
return factory.getService(process, service);
}
} catch (CoreException e) {
RemoteCorePlugin.log(e.getStatus());
}
}
return null;
}
@Override
public List getProcessServices() {
return new ArrayList<>(processServiceDefinitionMap.keySet());
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnectionType#hasProcessService(java.lang.Class)
*/
@Override
public boolean hasProcessService(Class service) {
return processServiceDefinitionMap.get(service.getName()) != null;
}
/**
* Called from the remote service manager to register a service extension for
* this remote services implementation
*
* @param ce
* the extension element defining the service
*/
public void addService(IConfigurationElement ce) {
String serviceName = ce.getAttribute("service"); //$NON-NLS-1$
String name = ce.getName();
switch (name) {
case "connectionTypeService": //$NON-NLS-1$
serviceDefinitionMap.put(serviceName, ce);
break;
case "connectionService": //$NON-NLS-1$
connectionServiceDefinitionMap.put(serviceName, ce);
break;
case "processService": //$NON-NLS-1$
processServiceDefinitionMap.put(serviceName, ce);
break;
}
}
/**
* Signal connection has been added.
*
* @since 2.0
*/
protected void connectionAdded(final IRemoteConnection connection) {
RemoteConnectionChangeEvent event = new RemoteConnectionChangeEvent(connection,
RemoteConnectionChangeEvent.CONNECTION_ADDED);
remoteServicesManager.fireRemoteConnectionChangeEvent(event);
}
/**
* Signal a connnection is about to be removed.
*
* @since 2.0
*/
protected void connectionRemoved(final IRemoteConnection connection) {
RemoteConnectionChangeEvent event = new RemoteConnectionChangeEvent(connection,
RemoteConnectionChangeEvent.CONNECTION_REMOVED);
remoteServicesManager.fireRemoteConnectionChangeEvent(event);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnectionType#getConnection(java.lang.String)
*/
@Override
public IRemoteConnection getConnection(String name) {
synchronized (connections) {
return connections.get(name);
}
}
@Override
public IRemoteConnection getConnection(URI uri) {
synchronized (connections) {
IRemoteConnection connection = connections.get(uri.getAuthority());
if (connection != null) {
return connection;
}
// If it's a file: scheme we must be the local connection type, just return our
// hopefully one connection, the Local connection.
if (uri.getScheme().equals("file") && !connections.isEmpty()) { //$NON-NLS-1$
return connections.values().iterator().next();
}
return null;
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnectionType#getConnections()
*/
@Override
public List getConnections() {
synchronized (connections) {
return new ArrayList(connections.values());
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnectionType#newConnection(java.lang.String)
*/
@Override
public IRemoteConnectionWorkingCopy newConnection(String name) throws RemoteConnectionException {
synchronized (connections) {
if (connections.containsKey(name)) {
throw new ConnectionExistsException(name);
}
return new RemoteConnectionWorkingCopy(this, name);
}
}
void addConnection(RemoteConnection remoteConnection) {
synchronized (connections) {
connections.put(remoteConnection.getName(), remoteConnection);
}
}
void removeConnection(String name) {
synchronized (connections) {
connections.remove(name);
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnectionType#removeConnection(org.eclipse.remote.core.IRemoteConnection)
*/
@Override
public void removeConnection(IRemoteConnection connection) throws RemoteConnectionException {
synchronized (connections) {
if (connection instanceof RemoteConnection) {
connection.close();
RemoteConnection conn = (RemoteConnection) connection;
try {
conn.getPreferences().removeNode();
} catch (BackingStoreException e) {
throw new RemoteConnectionException(e);
}
conn.getSecurePreferences().removeNode();
connections.remove(conn.getName());
connection.fireConnectionChangeEvent(RemoteConnectionChangeEvent.CONNECTION_REMOVED);
} else {
RemoteCorePlugin.log("Wrong class for " + connection.getName() + ", was " + connection.getClass().getName()); //$NON-NLS-1$ //$NON-NLS-2$
}
}
}
}
RemoteConnectionWorkingCopy.java 0000664 0000000 0000000 00000024777 12721140017 0041101 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core /*******************************************************************************
* Copyright (c) 2015 QNX Software Systems 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
*
* Contributors:
* QNX - initial API and implementation
*******************************************************************************/
package org.eclipse.remote.internal.core;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.equinox.security.storage.ISecurePreferences;
import org.eclipse.equinox.security.storage.StorageException;
import org.eclipse.remote.core.IRemoteConnection;
import org.eclipse.remote.core.IRemoteConnectionChangeListener;
import org.eclipse.remote.core.IRemoteConnectionControlService;
import org.eclipse.remote.core.IRemoteConnectionPropertyService;
import org.eclipse.remote.core.IRemoteConnectionType;
import org.eclipse.remote.core.IRemoteConnectionWorkingCopy;
import org.eclipse.remote.core.RemoteConnectionChangeEvent;
import org.eclipse.remote.core.exception.RemoteConnectionException;
import org.osgi.service.prefs.BackingStoreException;
import org.osgi.service.prefs.Preferences;
public class RemoteConnectionWorkingCopy implements IRemoteConnectionWorkingCopy {
private RemoteConnection original;
private final RemoteConnectionType connectionType;
private String newName;
private final Map newAttributes = new HashMap<>();
private final Map newSecureAttributes = new HashMap<>();
private final List newListeners = new ArrayList<>();
/**
* New Connection.
*/
public RemoteConnectionWorkingCopy(RemoteConnectionType connectionType, String name) {
this.connectionType = connectionType;
this.newName = name;
}
/**
* Edit Connection
*/
public RemoteConnectionWorkingCopy(RemoteConnection original) {
this.original = original;
this.connectionType = (RemoteConnectionType) original.getConnectionType();
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnection#getName()
*/
@Override
public String getName() {
if (newName != null) {
return newName;
}
if (original != null) {
return original.getName();
}
return null;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnectionWorkingCopy#setName(java.lang.String)
*/
@Override
public void setName(String name) {
// set it only if it's changed
if (original == null || !name.equals(original.getName())) {
newName = name;
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnection#getAttribute(java.lang.String)
*/
@Override
public String getAttribute(String key) {
String value = newAttributes.get(key);
if (value != null) {
return value;
}
if (original != null) {
return original.getAttribute(key);
}
return RemoteConnection.EMPTY_STRING;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnectionWorkingCopy#setAttribute(java.lang.String, java.lang.String)
*/
@Override
public void setAttribute(String key, String value) {
// set only if it's changed or value is null
if (original == null || value == null || !value.equals(original.getAttribute(key))) {
newAttributes.put(key, value);
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnection#getSecureAttribute(java.lang.String)
*/
@Override
public String getSecureAttribute(String key) {
String value = newSecureAttributes.get(key);
if (value != null) {
return value;
}
if (original != null) {
return original.getSecureAttribute(key);
}
return RemoteConnection.EMPTY_STRING;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnectionWorkingCopy#setSecureAttribute(java.lang.String, java.lang.String)
*/
@Override
public void setSecureAttribute(String key, String value) {
// set only if it's changed or value is null
if (original == null || value == null || !value.equals(original.getSecureAttribute(key))) {
newSecureAttributes.put(key, value);
}
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.remote.core.IRemoteConnection#addConnectionChangeListener(org.eclipse.remote.core.IRemoteConnectionChangeListener
* )
*/
@Override
public void addConnectionChangeListener(IRemoteConnectionChangeListener listener) {
if (original != null) {
original.addConnectionChangeListener(listener);
} else {
newListeners.add(listener);
}
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.remote.core.IRemoteConnection#removeConnectionChangeListener(org.eclipse.remote.core.IRemoteConnectionChangeListener
* )
*/
@Override
public void removeConnectionChangeListener(IRemoteConnectionChangeListener listener) {
if (original != null) {
original.removeConnectionChangeListener(listener);
} else {
newListeners.remove(listener);
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnection#fireConnectionChangeEvent(int)
*/
@Override
public void fireConnectionChangeEvent(int type) {
if (original != null && type != RemoteConnectionChangeEvent.CONNECTION_RENAMED) {
original.fireConnectionChangeEvent(type);
} else {
RemoteConnectionChangeEvent event = new RemoteConnectionChangeEvent(this, type);
for (IRemoteConnectionChangeListener listener : newListeners) {
listener.connectionChanged(event);
}
connectionType.getRemoteServicesManager().fireRemoteConnectionChangeEvent(event);
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnection#getConnectionType()
*/
@Override
public IRemoteConnectionType getConnectionType() {
return connectionType;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnection#getWorkingCopy()
*/
@Override
public IRemoteConnectionWorkingCopy getWorkingCopy() {
return this;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnection#getService(java.lang.Class)
*/
@Override
public T getService(Class service) {
return connectionType.getConnectionService(this, service);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnection#hasService(java.lang.Class)
*/
@Override
public boolean hasService(Class service) {
if (original != null) {
return original.hasService(service);
} else {
return connectionType.hasConnectionService(service);
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnectionWorkingCopy#getOriginal()
*/
@Override
public IRemoteConnection getOriginal() {
return original;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnectionWorkingCopy#isDirty()
*/
@Override
public boolean isDirty() {
return newName != null || !newAttributes.isEmpty() || !newSecureAttributes.isEmpty();
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnectionWorkingCopy#save()
*/
@Override
public IRemoteConnection save() throws RemoteConnectionException {
if (newName != null && original != null) {
// rename, delete the old one
fireConnectionChangeEvent(RemoteConnectionChangeEvent.CONNECTION_RENAMED);
connectionType.removeConnection(original.getName());
original.rename(newName);
}
boolean added = false;
if (original == null) {
original = new RemoteConnection(connectionType, newName);
added = true;
}
Preferences prefs = original.getPreferences();
for (Map.Entry entry : newAttributes.entrySet()) {
String value = entry.getValue();
if (value != null && !value.isEmpty()) {
prefs.put(entry.getKey(), value);
} else {
prefs.remove(entry.getKey());
}
}
try {
prefs.flush();
} catch (BackingStoreException e1) {
throw new RemoteConnectionException(e1);
}
ISecurePreferences securePrefs = original.getSecurePreferences();
for (Map.Entry entry : newSecureAttributes.entrySet()) {
String value = entry.getValue();
if (value != null && !value.isEmpty()) {
try {
securePrefs.put(entry.getKey(), value, true);
} catch (StorageException e) {
throw new RemoteConnectionException(e);
}
} else {
securePrefs.remove(entry.getKey());
}
}
try {
securePrefs.flush();
} catch (IOException e) {
throw new RemoteConnectionException(e);
}
/*
* Reset state for isDirty()
*/
newAttributes.clear();
newSecureAttributes.clear();
newName = null;
connectionType.addConnection(original);
if (added) {
original.fireConnectionChangeEvent(RemoteConnectionChangeEvent.CONNECTION_ADDED);
}
return original;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnection#open(org.eclipse.core.runtime.IProgressMonitor)
*/
@Override
public void open(IProgressMonitor monitor) throws RemoteConnectionException {
if (original != null) {
original.open(monitor);
} else {
IRemoteConnectionControlService controlService = connectionType.getConnectionService(this,
IRemoteConnectionControlService.class);
if (controlService != null) {
controlService.open(monitor);
}
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnection#close()
*/
@Override
public void close() {
if (original != null) {
original.close();
} else {
IRemoteConnectionControlService controlService = connectionType.getConnectionService(this,
IRemoteConnectionControlService.class);
if (controlService != null) {
controlService.close();
}
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnection#isOpen()
*/
@Override
public boolean isOpen() {
if (original != null) {
return original.isOpen();
}
IRemoteConnectionControlService controlService = connectionType.getConnectionService(this,
IRemoteConnectionControlService.class);
if (controlService != null) {
return controlService.isOpen();
}
return true;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnection#getProperty(java.lang.String)
*/
@Override
public String getProperty(String key) {
if (original != null) {
return original.getProperty(key);
}
IRemoteConnectionPropertyService propertyService = connectionType.getConnectionService(this,
IRemoteConnectionPropertyService.class);
if (propertyService != null) {
return propertyService.getProperty(key);
}
return null;
}
}
RemoteCorePlugin.java 0000664 0000000 0000000 00000010354 12721140017 0036637 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core /*******************************************************************************
* Copyright (c) 2007, 2010 IBM Corporation 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
*
* Contributors:
* IBM Corporation - Initial API and implementation
*******************************************************************************/
package org.eclipse.remote.internal.core;
import org.eclipse.core.resources.ISaveContext;
import org.eclipse.core.resources.ISaveParticipant;
import org.eclipse.core.resources.ResourcesPlugin;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Plugin;
import org.eclipse.core.runtime.Status;
import org.eclipse.remote.core.IRemoteServicesManager;
import org.eclipse.remote.core.launch.IRemoteLaunchConfigService;
import org.eclipse.remote.internal.core.launch.RemoteLaunchConfigService;
import org.eclipse.remote.internal.core.preferences.Preferences;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceReference;
/**
* The activator class controls the plug-in life cycle
*/
public class RemoteCorePlugin extends Plugin {
private static final String PLUGIN_ID = "org.eclipse.remote.core"; //$NON-NLS-1$
// The shared instance
private static RemoteCorePlugin plugin;
/**
* Returns the shared instance
*
* @return the shared instance
*/
public static RemoteCorePlugin getDefault() {
return plugin;
}
/**
* Get unique identifier for this plugin
*/
public static String getUniqueIdentifier() {
if (getDefault() == null) {
return PLUGIN_ID;
}
return getDefault().getBundle().getSymbolicName();
}
/**
* Logs the specified status with this plug-in's log.
*
* @param status
* status to log
*/
public static void log(IStatus status) {
getDefault().getLog().log(status);
}
/**
* Logs an internal error with the specified message.
*
* @param message
* the error message to log
*/
public static void log(String message) {
log(new Status(IStatus.ERROR, getUniqueIdentifier(), IStatus.ERROR, message, null));
}
/**
* Logs an internal error with the specified throwable
*
* @param e
* the exception to be logged
*/
public static void log(Throwable e) {
log(new Status(IStatus.ERROR, getUniqueIdentifier(), IStatus.ERROR, e.getMessage(), e));
}
/**
* Return the OSGi service with the given service interface.
*
* @param service service interface
* @return the specified service or null if it's not registered
*/
public static T getService(Class service) {
BundleContext context = plugin.getBundle().getBundleContext();
ServiceReference ref = context.getServiceReference(service);
return ref != null ? context.getService(ref) : null;
}
/**
* The constructor
*/
public RemoteCorePlugin() {
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext )
*/
@Override
public void start(BundleContext context) throws Exception {
super.start(context);
plugin = this;
context.registerService(IRemoteServicesManager.class, new RemoteServicesManager(), null);
context.registerService(IRemoteLaunchConfigService.class, new RemoteLaunchConfigService(), null);
RemoteDebugOptions.configure(context);
ResourcesPlugin.getWorkspace().addSaveParticipant(getUniqueIdentifier(), new ISaveParticipant() {
@Override
public void saving(ISaveContext saveContext) throws CoreException {
Preferences.savePreferences();
}
@Override
public void rollback(ISaveContext saveContext) {
// Do nothing
}
@Override
public void prepareToSave(ISaveContext saveContext) throws CoreException {
// Do nothing
}
@Override
public void doneSaving(ISaveContext saveContext) {
// Do nothing
}
});
}
/*
* (non-Javadoc)
*
* @see org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext )
*/
@Override
public void stop(BundleContext context) throws Exception {
Preferences.savePreferences();
plugin = null;
super.stop(context);
}
}
RemoteDebugOptions.java 0000664 0000000 0000000 00000007776 12721140017 0037210 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core /*******************************************************************************
* Copyright (c) 2012 Sage Electronic Engineering, LLC. 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
*
* Contributors:
* Jason Litton (Sage Electronic Engineering, LLC) - initial API and implementation
* Greg Watson (IBM) - adapted for remote core
*******************************************************************************/
package org.eclipse.remote.internal.core;
import java.util.Hashtable;
import org.eclipse.osgi.service.debug.DebugOptions;
import org.eclipse.osgi.service.debug.DebugOptionsListener;
import org.eclipse.osgi.service.debug.DebugTrace;
import org.eclipse.osgi.util.NLS;
import org.osgi.framework.BundleContext;
/**
* Hooks our debug options to the Platform trace functonality.
* In essence, we can open Window -> Preferences -> Tracing
* and turn on debug options for this package. The debug output
* will come out on the console and can be saved directly to
* a file. Classes that need to be debugged can call into
* RemoteDebugOptions to get debug flags. If new flags need to be
* created, they will need to have a unique identifier and added to
* the .options file in this plugin
*/
public class RemoteDebugOptions implements DebugOptionsListener {
public static final String DEBUG_REMOTE_COMMANDS = "/debug/commands"; //$NON-NLS-1$
private static DebugTrace fDebugTrace;
private static DebugOptions fDebugOptions;
private static RemoteDebugOptions fRemoteDebugOptions;
public static void configure(BundleContext context) {
if (fRemoteDebugOptions == null) {
fRemoteDebugOptions = new RemoteDebugOptions(context);
}
}
private RemoteDebugOptions(BundleContext context) {
Hashtable props = new Hashtable(2);
props.put(DebugOptions.LISTENER_SYMBOLICNAME, RemoteCorePlugin.getUniqueIdentifier());
context.registerService(DebugOptionsListener.class.getName(), this, props);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.osgi.service.debug.DebugOptionsListener#optionsChanged(org.eclipse.osgi.service.debug.DebugOptions)
*/
@Override
public void optionsChanged(DebugOptions options) {
fDebugOptions = options;
fDebugTrace = options.newDebugTrace(RemoteCorePlugin.getUniqueIdentifier());
}
public static boolean isDebugging() {
return RemoteCorePlugin.getDefault().isDebugging();
}
public static boolean isDebugging(String option) {
if (fDebugOptions == null) {
return false;
}
return fDebugOptions.getBooleanOption(RemoteCorePlugin.getUniqueIdentifier() + option, false);
}
public static void setDebugging(String option, boolean value) {
if (fDebugOptions != null) {
if (value) {
fDebugOptions.setDebugEnabled(true);
}
fDebugOptions.setOption(option, Boolean.toString(value));
}
}
/**
* Prints the given message to System.out and to the OSGi tracing (if enabled)
*
* @param message
* the message or null
*/
public static void trace(String message) {
trace(null, message);
}
/**
* Prints the given message to System.out and to the OSGi tracing (if enabled)
*
* @param option
* the option to determine if tracing is displayed
* @param message
* the message or null
* @param arguments
* optional arguments for the message or null
*/
public static void trace(String option, String message, String... arguments) {
String traceMsg = message;
if (arguments.length > 0) {
traceMsg = NLS.bind(message, arguments);
}
if ((option != null && isDebugging(option)) || isDebugging()) {
System.out.println(traceMsg);
if (fDebugTrace != null) {
fDebugTrace.trace(option, traceMsg, null);
}
}
}
}
RemotePath.java 0000664 0000000 0000000 00000113732 12721140017 0035470 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core /*******************************************************************************
* Copyright (c) 2000, 2015 IBM Corporation 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
*
* Contributors:
* IBM Corporation - initial API and implementation
* Patrick Tasse - Add extra constructor to Path class (bug 454959)
* Martin Oberhuber - [468889] Copy from equinox.common/org.eclipse.core.runtime
*******************************************************************************/
package org.eclipse.remote.internal.core;
import java.io.File;
import java.util.Arrays;
import org.eclipse.core.runtime.Assert;
import org.eclipse.core.runtime.IPath;
/**
* The Eclipse Mars implementation of org.eclipse.core.runtime.Path.
*
* Cloned from org.eclipse.equinox.common. This class should be removed when
* Eclipse older than Mars no longer needs to be supported.
*
* @see org.eclipse.core.runtime.Path
* @noextend This class is not intended to be subclassed by clients.
*/
public class RemotePath implements IPath, Cloneable {
/** masks for flag values */
private static final int HAS_LEADING = 1;
private static final int IS_UNC = 2;
private static final int HAS_TRAILING = 4;
private static final int IS_FOR_WINDOWS = 8;
private static final int ALL_SEPARATORS = HAS_LEADING | IS_UNC | HAS_TRAILING;
private static final int ALL_FLAGS = HAS_LEADING | IS_UNC | HAS_TRAILING | IS_FOR_WINDOWS;
/** Constant value indicating if the current platform is Windows */
private static final boolean RUNNING_ON_WINDOWS = java.io.File.separatorChar == '\\';
/** Constant empty string value. */
private static final String EMPTY_STRING = ""; //$NON-NLS-1$
/** Constant value indicating no segments */
private static final String[] NO_SEGMENTS = new String[0];
/** Constant value containing the empty path with no device on the local file system. */
public static final RemotePath EMPTY = new RemotePath(EMPTY_STRING);
/** Mask for all bits that are involved in the hash code */
private static final int HASH_MASK = ~(HAS_TRAILING | IS_FOR_WINDOWS);
/** Constant root path string ("/"). */
private static final String ROOT_STRING = "/"; //$NON-NLS-1$
/** Constant value containing the root path with no device on the local file system. */
public static final RemotePath ROOT = new RemotePath(ROOT_STRING);
/** The device id string. May be null if there is no device. */
private String device = null;
//Private implementation note: the segments array and flag bitmap
//are never modified, so that they can be shared between path instances
/** The path segments */
private String[] segments;
/** flags indicating separators (has leading, is UNC, has trailing, is for Windows) */
private int flags;
/**
* Constructs a new path from the given string path.
* The string path must represent a valid file system path
* on the local file system.
* The path is canonicalized and double slashes are removed
* except at the beginning. (to handle UNC paths). All forward
* slashes ('/') are treated as segment delimiters, and any
* segment and device delimiters for the local file system are
* also respected.
*
* @param pathString the portable string path
* @see IPath#toPortableString()
* @since 3.1
*/
public static IPath fromOSString(String pathString) {
return new RemotePath(pathString);
}
/**
* Constructs a new path from the given path string.
* The path string must have been produced by a previous
* call to IPath.toPortableString.
*
* @param pathString the portable path string
* @see IPath#toPortableString()
* @since 3.1
*/
public static IPath fromPortableString(String pathString) {
int firstMatch = pathString.indexOf(DEVICE_SEPARATOR) + 1;
//no extra work required if no device characters
if (firstMatch <= 0)
return new RemotePath().initialize(null, pathString, RUNNING_ON_WINDOWS);
//if we find a single colon, then the path has a device
String devicePart = null;
int pathLength = pathString.length();
if (firstMatch == pathLength || pathString.charAt(firstMatch) != DEVICE_SEPARATOR) {
devicePart = pathString.substring(0, firstMatch);
pathString = pathString.substring(firstMatch, pathLength);
}
//optimize for no colon literals
if (pathString.indexOf(DEVICE_SEPARATOR) == -1)
return new RemotePath().initialize(devicePart, pathString, RUNNING_ON_WINDOWS);
//contract colon literals
char[] chars = pathString.toCharArray();
int readOffset = 0, writeOffset = 0, length = chars.length;
while (readOffset < length) {
if (chars[readOffset] == DEVICE_SEPARATOR)
if (++readOffset >= length)
break;
chars[writeOffset++] = chars[readOffset++];
}
return new RemotePath().initialize(devicePart, new String(chars, 0, writeOffset), RUNNING_ON_WINDOWS);
}
/**
* Constructs a new POSIX path from the given string path. The string path
* must represent a valid file system path on a POSIX file system. The path
* is canonicalized and double slashes are removed except at the beginning
* (to handle UNC paths). All forward slashes ('/') are treated as segment
* delimiters. This factory method should be used if the string path is for
* a POSIX file system.
*
* @param fullPath the string path
* @see #isValidPosixPath(String)
* @since 3.7
*/
public static RemotePath forPosix(String fullPath) {
return new RemotePath(fullPath, false);
}
/**
* Constructs a new Windows path from the given string path. The string path
* must represent a valid file system path on the Windows file system. The
* path is canonicalized and double slashes are removed except at the
* beginning (to handle UNC paths). All forward slashes ('/') are treated as
* segment delimiters, and any segment ('\') and device (':') delimiters for
* the Windows file system are also respected. This factory method should be
* used if the string path is for the Windows file system.
*
* @param fullPath the string path
* @see #isValidWindowsPath(String)
* @since 3.7
*/
public static RemotePath forWindows(String fullPath) {
return new RemotePath(fullPath, true);
}
/* (Intentionally not included in javadoc)
* Private constructor.
*/
private RemotePath() {
// not allowed
}
/**
* Constructs a new path from the given string path.
* The string path must represent a valid file system path
* on the local file system.
* The path is canonicalized and double slashes are removed
* except at the beginning. (to handle UNC paths). All forward
* slashes ('/') are treated as segment delimiters, and any
* segment and device delimiters for the local file system are
* also respected (such as colon (':') and backslash ('\') on some file systems).
* This constructor should be used if the string path if for the local file system.
*
* @param fullPath the string path
* @see #isValidPath(String)
*/
public RemotePath(String fullPath) {
this(fullPath, RUNNING_ON_WINDOWS);
}
/**
* Constructs a new path from the given device id and string path.
* The given string path must be valid.
* The path is canonicalized and double slashes are removed except
* at the beginning (to handle UNC paths). All forward
* slashes ('/') are treated as segment delimiters, and any
* segment delimiters for the local file system are
* also respected (such as backslash ('\') on some file systems).
*
* @param device the device id
* @param path the string path
* @see #isValidPath(String)
* @see #setDevice(String)
*/
public RemotePath(String device, String path) {
if (RUNNING_ON_WINDOWS) {
//convert backslash to forward slash
path = path.indexOf('\\') == -1 ? path : path.replace('\\', SEPARATOR);
}
initialize(device, path, RUNNING_ON_WINDOWS);
}
/**
* Constructs a new path from the given string path. The string path must
* represent a valid file system path on the specified file system. The path
* is canonicalized and double slashes are removed except at the beginning
* (to handle UNC paths). All forward slashes ('/') are treated as segment
* delimiters, and any segment and device delimiters for the specified file
* system are also respected (such as colon (':') and backslash ('\') on
* Windows).
*
* @param fullPath the string path
* @param forWindows true if the string path is for the Windows file system
* @since 3.7
*/
private RemotePath(String fullPath, boolean forWindows) {
String devicePart = null;
if (forWindows) {
//convert backslash to forward slash
fullPath = fullPath.indexOf('\\') == -1 ? fullPath : fullPath.replace('\\', SEPARATOR);
//extract device
int i = fullPath.indexOf(DEVICE_SEPARATOR);
if (i != -1) {
//remove leading slash from device part to handle output of URL.getFile()
int start = fullPath.charAt(0) == SEPARATOR ? 1 : 0;
devicePart = fullPath.substring(start, i + 1);
fullPath = fullPath.substring(i + 1, fullPath.length());
}
}
initialize(devicePart, fullPath, forWindows);
}
/* (Intentionally not included in javadoc)
* Private constructor.
*/
private RemotePath(String device, String[] segments, int flags) {
// no segment validations are done for performance reasons
this.segments = segments;
this.device = device;
//hash code is cached in all but the bottom four bits of the flags field
this.flags = (computeHashCode() << 4) | (flags & ALL_FLAGS);
}
/* (Intentionally not included in javadoc)
* @see IPath#addFileExtension
*/
@Override
public IPath addFileExtension(String extension) {
if (isRoot() || isEmpty() || hasTrailingSeparator())
return this;
int len = segments.length;
String[] newSegments = new String[len];
System.arraycopy(segments, 0, newSegments, 0, len - 1);
newSegments[len - 1] = segments[len - 1] + '.' + extension;
return new RemotePath(device, newSegments, flags);
}
/* (Intentionally not included in javadoc)
* @see IPath#addTrailingSeparator
*/
@Override
public IPath addTrailingSeparator() {
if (hasTrailingSeparator() || isRoot()) {
return this;
}
//XXX workaround, see 1GIGQ9V
if (isEmpty()) {
return new RemotePath(device, segments, (flags & IS_FOR_WINDOWS) | HAS_LEADING);
}
return new RemotePath(device, segments, flags | HAS_TRAILING);
}
/* (Intentionally not included in javadoc)
* @see IPath#append(IPath)
*/
@Override
public IPath append(IPath tail) {
//optimize some easy cases
if (tail == null || tail.segmentCount() == 0)
return this;
//these call chains look expensive, but in most cases they are no-ops
//the tail must be for the same platform as this instance
if (this.isEmpty() && ((flags & IS_FOR_WINDOWS) == 0) == tail.isValidSegment(":")) //$NON-NLS-1$
return tail.setDevice(device).makeRelative().makeUNC(isUNC());
if (this.isRoot() && ((flags & IS_FOR_WINDOWS) == 0) == tail.isValidSegment(":")) //$NON-NLS-1$
return tail.setDevice(device).makeAbsolute().makeUNC(isUNC());
//concatenate the two segment arrays
int myLen = segments.length;
int tailLen = tail.segmentCount();
String[] newSegments = new String[myLen + tailLen];
System.arraycopy(segments, 0, newSegments, 0, myLen);
for (int i = 0; i < tailLen; i++) {
newSegments[myLen + i] = tail.segment(i);
}
//use my leading separators and the tail's trailing separator
RemotePath result = new RemotePath(device, newSegments, (flags & (HAS_LEADING | IS_UNC | IS_FOR_WINDOWS)) | (tail.hasTrailingSeparator() ? HAS_TRAILING : 0));
String tailFirstSegment = newSegments[myLen];
if (tailFirstSegment.equals("..") || tailFirstSegment.equals(".")) { //$NON-NLS-1$ //$NON-NLS-2$
result.canonicalize();
}
return result;
}
/* (Intentionally not included in javadoc)
* @see IPath#append(java.lang.String)
*/
@Override
public IPath append(String tail) {
//optimize addition of a single segment
if (tail.indexOf(SEPARATOR) == -1 && tail.indexOf("\\") == -1 && tail.indexOf(DEVICE_SEPARATOR) == -1) { //$NON-NLS-1$
int tailLength = tail.length();
if (tailLength < 3) {
//some special cases
if (tailLength == 0 || ".".equals(tail)) { //$NON-NLS-1$
return this;
}
if ("..".equals(tail)) //$NON-NLS-1$
return removeLastSegments(1);
}
//just add the segment
int myLen = segments.length;
String[] newSegments = new String[myLen + 1];
System.arraycopy(segments, 0, newSegments, 0, myLen);
newSegments[myLen] = tail;
return new RemotePath(device, newSegments, flags & ~HAS_TRAILING);
}
//go with easy implementation
return append(new RemotePath(tail, (flags & IS_FOR_WINDOWS) != 0));
}
/**
* Destructively converts this path to its canonical form.
*
* In its canonical form, a path does not have any
* "." segments, and parent references ("..") are collapsed
* where possible.
*
* @return true if the path was modified, and false otherwise.
*/
private boolean canonicalize() {
//look for segments that need canonicalizing
for (int i = 0, max = segments.length; i < max; i++) {
String segment = segments[i];
if (segment.charAt(0) == '.' && (segment.equals("..") || segment.equals("."))) { //$NON-NLS-1$ //$NON-NLS-2$
//path needs to be canonicalized
collapseParentReferences();
//paths of length 0 have no trailing separator
if (segments.length == 0)
flags &= (HAS_LEADING | IS_UNC);
//recompute hash because canonicalize affects hash
flags = (flags & ALL_FLAGS) | (computeHashCode() << 4);
return true;
}
}
return false;
}
/* (Intentionally not included in javadoc)
* Clones this object.
*/
@Override
public Object clone() {
try {
return super.clone();
} catch (CloneNotSupportedException e) {
return null;
}
}
/**
* Destructively removes all occurrences of ".." segments from this path.
*/
private void collapseParentReferences() {
int segmentCount = segments.length;
String[] stack = new String[segmentCount];
int stackPointer = 0;
for (int i = 0; i < segmentCount; i++) {
String segment = segments[i];
if (segment.equals("..")) { //$NON-NLS-1$
if (stackPointer == 0) {
// if the stack is empty we are going out of our scope
// so we need to accumulate segments. But only if the original
// path is relative. If it is absolute then we can't go any higher than
// root so simply toss the .. references.
if (!isAbsolute())
stack[stackPointer++] = segment; //stack push
} else {
// if the top is '..' then we are accumulating segments so don't pop
if ("..".equals(stack[stackPointer - 1])) //$NON-NLS-1$
stack[stackPointer++] = ".."; //$NON-NLS-1$
else
stackPointer--;
//stack pop
}
//collapse current references
} else if (!segment.equals(".") || segmentCount == 1) //$NON-NLS-1$
stack[stackPointer++] = segment; //stack push
}
//if the number of segments hasn't changed, then no modification needed
if (stackPointer == segmentCount)
return;
//build the new segment array backwards by popping the stack
String[] newSegments = new String[stackPointer];
System.arraycopy(stack, 0, newSegments, 0, stackPointer);
this.segments = newSegments;
}
/**
* Removes duplicate slashes from the given path, with the exception
* of leading double slash which represents a UNC path.
*/
private String collapseSlashes(String path) {
int length = path.length();
// if the path is only 0, 1 or 2 chars long then it could not possibly have illegal
// duplicate slashes.
if (length < 3)
return path;
// check for an occurrence of // in the path. Start at index 1 to ensure we skip leading UNC //
// If there are no // then there is nothing to collapse so just return.
if (path.indexOf("//", 1) == -1) //$NON-NLS-1$
return path;
// We found an occurrence of // in the path so do the slow collapse.
char[] result = new char[path.length()];
int count = 0;
boolean hasPrevious = false;
char[] characters = path.toCharArray();
for (int index = 0; index < characters.length; index++) {
char c = characters[index];
if (c == SEPARATOR) {
if (hasPrevious) {
// skip double slashes, except for beginning of UNC.
// note that a UNC path can't have a device.
if (device == null && index == 1) {
result[count] = c;
count++;
}
} else {
hasPrevious = true;
result[count] = c;
count++;
}
} else {
hasPrevious = false;
result[count] = c;
count++;
}
}
return new String(result, 0, count);
}
/* (Intentionally not included in javadoc)
* Computes the hash code for this object.
*/
private int computeHashCode() {
int hash = device == null ? 17 : device.hashCode();
int segmentCount = segments.length;
for (int i = 0; i < segmentCount; i++) {
//this function tends to given a fairly even distribution
hash = hash * 37 + segments[i].hashCode();
}
return hash;
}
/* (Intentionally not included in javadoc)
* Returns the size of the string that will be created by toString or toOSString.
*/
private int computeLength() {
int length = 0;
if (device != null)
length += device.length();
if ((flags & HAS_LEADING) != 0)
length++;
if ((flags & IS_UNC) != 0)
length++;
//add the segment lengths
int max = segments.length;
if (max > 0) {
for (int i = 0; i < max; i++) {
length += segments[i].length();
}
//add the separator lengths
length += max - 1;
}
if ((flags & HAS_TRAILING) != 0)
length++;
return length;
}
/* (Intentionally not included in javadoc)
* Returns the number of segments in the given path
*/
private int computeSegmentCount(String path) {
int len = path.length();
if (len == 0 || (len == 1 && path.charAt(0) == SEPARATOR)) {
return 0;
}
int count = 1;
int prev = -1;
int i;
while ((i = path.indexOf(SEPARATOR, prev + 1)) != -1) {
if (i != prev + 1 && i != len) {
++count;
}
prev = i;
}
if (path.charAt(len - 1) == SEPARATOR) {
--count;
}
return count;
}
/**
* Computes the segment array for the given canonicalized path.
*/
private String[] computeSegments(String path) {
// performance sensitive --- avoid creating garbage
int segmentCount = computeSegmentCount(path);
if (segmentCount == 0)
return NO_SEGMENTS;
String[] newSegments = new String[segmentCount];
int len = path.length();
// check for initial slash
int firstPosition = (path.charAt(0) == SEPARATOR) ? 1 : 0;
// check for UNC
if (firstPosition == 1 && len > 1 && (path.charAt(1) == SEPARATOR))
firstPosition = 2;
int lastPosition = (path.charAt(len - 1) != SEPARATOR) ? len - 1 : len - 2;
// for non-empty paths, the number of segments is
// the number of slashes plus 1, ignoring any leading
// and trailing slashes
int next = firstPosition;
for (int i = 0; i < segmentCount; i++) {
int start = next;
int end = path.indexOf(SEPARATOR, next);
if (end == -1) {
newSegments[i] = path.substring(start, lastPosition + 1);
} else {
newSegments[i] = path.substring(start, end);
}
next = end + 1;
}
return newSegments;
}
/**
* Returns the platform-neutral encoding of the given segment onto
* the given string buffer. This escapes literal colon characters with double colons.
*/
private void encodeSegment(String string, StringBuffer buf) {
int len = string.length();
for (int i = 0; i < len; i++) {
char c = string.charAt(i);
buf.append(c);
if (c == DEVICE_SEPARATOR)
buf.append(DEVICE_SEPARATOR);
}
}
/* (Intentionally not included in javadoc)
* Compares objects for equality.
*/
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (!(obj instanceof RemotePath))
return false;
RemotePath target = (RemotePath) obj;
//check leading separators and hash code
if ((flags & HASH_MASK) != (target.flags & HASH_MASK))
return false;
String[] targetSegments = target.segments;
int i = segments.length;
//check segment count
if (i != targetSegments.length)
return false;
//check segments in reverse order - later segments more likely to differ
while (--i >= 0)
if (!segments[i].equals(targetSegments[i]))
return false;
//check device last (least likely to differ)
return device == target.device || (device != null && device.equals(target.device));
}
/* (Intentionally not included in javadoc)
* @see IPath#getDevice
*/
@Override
public String getDevice() {
return device;
}
/* (Intentionally not included in javadoc)
* @see IPath#getFileExtension
*/
@Override
public String getFileExtension() {
if (hasTrailingSeparator()) {
return null;
}
String lastSegment = lastSegment();
if (lastSegment == null) {
return null;
}
int index = lastSegment.lastIndexOf('.');
if (index == -1) {
return null;
}
return lastSegment.substring(index + 1);
}
/* (Intentionally not included in javadoc)
* Computes the hash code for this object.
*/
@Override
public int hashCode() {
return flags & HASH_MASK;
}
/* (Intentionally not included in javadoc)
* @see IPath#hasTrailingSeparator2
*/
@Override
public boolean hasTrailingSeparator() {
return (flags & HAS_TRAILING) != 0;
}
/*
* Initialize the current path with the given string.
*/
private IPath initialize(String deviceString, String path, boolean forWindows) {
Assert.isNotNull(path);
this.device = deviceString;
path = collapseSlashes(path);
int len = path.length();
//compute the flags bitmap
if (len < 2) {
if (len == 1 && path.charAt(0) == SEPARATOR) {
this.flags = HAS_LEADING;
} else {
this.flags = 0;
}
} else {
boolean hasLeading = path.charAt(0) == SEPARATOR;
boolean isUNC = hasLeading && path.charAt(1) == SEPARATOR;
//UNC path of length two has no trailing separator
boolean hasTrailing = !(isUNC && len == 2) && path.charAt(len - 1) == SEPARATOR;
flags = hasLeading ? HAS_LEADING : 0;
if (isUNC)
flags |= IS_UNC;
if (hasTrailing)
flags |= HAS_TRAILING;
}
if (forWindows) {
flags |= IS_FOR_WINDOWS;
}
//compute segments and ensure canonical form
segments = computeSegments(path);
if (!canonicalize()) {
//compute hash now because canonicalize didn't need to do it
flags = (flags & ALL_FLAGS) | (computeHashCode() << 4);
}
return this;
}
/* (Intentionally not included in javadoc)
* @see IPath#isAbsolute
*/
@Override
public boolean isAbsolute() {
//it's absolute if it has a leading separator
return (flags & HAS_LEADING) != 0;
}
/* (Intentionally not included in javadoc)
* @see IPath#isEmpty
*/
@Override
public boolean isEmpty() {
//true if no segments and no leading prefix
return segments.length == 0 && ((flags & ALL_SEPARATORS) != HAS_LEADING);
}
/* (Intentionally not included in javadoc)
* @see IPath#isPrefixOf
*/
@Override
public boolean isPrefixOf(IPath anotherPath) {
if (device == null) {
if (anotherPath.getDevice() != null) {
return false;
}
} else {
if (!device.equalsIgnoreCase(anotherPath.getDevice())) {
return false;
}
}
if (isEmpty() || (isRoot() && anotherPath.isAbsolute())) {
return true;
}
int len = segments.length;
if (len > anotherPath.segmentCount()) {
return false;
}
for (int i = 0; i < len; i++) {
if (!segments[i].equals(anotherPath.segment(i)))
return false;
}
return true;
}
/* (Intentionally not included in javadoc)
* @see IPath#isRoot
*/
@Override
public boolean isRoot() {
//must have no segments, a leading separator, and not be a UNC path.
return this == ROOT || (segments.length == 0 && ((flags & ALL_SEPARATORS) == HAS_LEADING));
}
/* (Intentionally not included in javadoc)
* @see IPath#isUNC
*/
@Override
public boolean isUNC() {
if (device != null)
return false;
return (flags & IS_UNC) != 0;
}
/* (Intentionally not included in javadoc)
* @see IPath#isValidPath(String)
*/
@Override
public boolean isValidPath(String path) {
return isValidPath(path, (flags & IS_FOR_WINDOWS) != 0);
}
/**
* Returns whether the given string is syntactically correct as a path on a
* POSIX file system. The path is correct if each of the segments in its
* canonicalized form is valid.
*
* @param path the path to check
* @return true if the given string is a valid path,
* and false otherwise
* @see #isValidPosixSegment(String)
* @since 3.7
*/
public static boolean isValidPosixPath(String path) {
return isValidPath(path, false);
}
/**
* Returns whether the given string is syntactically correct as a path on
* the Windows file system. The device id is the prefix up to and including
* the device separator (':'); the path proper is everything to the right of
* it, or the entire string if there is no device separator. The device id
* is not checked for validity; the path proper is correct if each of the
* segments in its canonicalized form is valid.
*
* @param path the path to check
* @return true if the given string is a valid path,
* and false otherwise
* @see #isValidWindowsSegment(String)
* @since 3.7
*/
public static boolean isValidWindowsPath(String path) {
return isValidPath(path, true);
}
/**
* Returns whether the given string is syntactically correct as a path on
* the specified file system. The device id is the prefix up to and
* including the device separator for the specified file system; the path
* proper is everything to the right of it, or the entire string if there is
* no device separator. When the specified platform is a file system with no
* meaningful device separator, the entire string is treated as the path
* proper. The device id is not checked for validity; the path proper is
* correct if each of the segments in its canonicalized form is valid.
*
* @param path the path to check
* @param forWindows true if the path is for the Windows file system
* @return true if the given string is a valid path,
* and false otherwise
* @see #isValidSegment(String, boolean)
* @since 3.7
*/
private static boolean isValidPath(String path, boolean forWindows) {
RemotePath test = new RemotePath(path, forWindows);
for (int i = 0, max = test.segmentCount(); i < max; i++)
if (!RemotePath.isValidSegment(test.segment(i), forWindows))
return false;
return true;
}
/* (Intentionally not included in javadoc)
* @see IPath#isValidSegment(String)
*/
@Override
public boolean isValidSegment(String segment) {
return isValidSegment(segment, (flags & IS_FOR_WINDOWS) != 0);
}
/**
* Returns whether the given string is valid as a segment in a path on a
* POSIX file system. The rules for valid segments are as follows:
*
*
the empty string is not valid
*
any string containing the slash character ('/') is not valid
*
*
* @param segment the path segment to check
* @return true if the given path segment is valid,
* and false otherwise
* @since 3.7
*/
public static boolean isValidPosixSegment(String segment) {
return isValidSegment(segment, false);
}
/**
* Returns whether the given string is valid as a segment in a path on the
* Windows file system. The rules for valid segments are as follows:
*
*
the empty string is not valid
*
any string containing the slash character ('/') is not valid
*
any string containing segment ('\') or device (':') separator
* characters is not valid
*
*
* @param segment the path segment to check
* @return true if the given path segment is valid,
* and false otherwise
* @since 3.7
*/
public static boolean isValidWindowsSegment(String segment) {
return isValidSegment(segment, true);
}
/**
* Returns whether the given string is valid as a segment in a path on the
* specified file system. The rules for valid segments are as follows:
*
*
the empty string is not valid
*
any string containing the slash character ('/') is not valid
*
any string containing segment or device separator characters on the
* specified file system, such as the backslash ('\') and colon (':') on
* Windows, is not valid
*
*
* @param segment the path segment to check
* @param forWindows true if the path is for the Windows file system
* @return true if the given path segment is valid,
* and false otherwise
* @since 3.7
*/
private static boolean isValidSegment(String segment, boolean forWindows) {
int size = segment.length();
if (size == 0)
return false;
for (int i = 0; i < size; i++) {
char c = segment.charAt(i);
if (c == '/')
return false;
if (forWindows && (c == '\\' || c == ':'))
return false;
}
return true;
}
/* (Intentionally not included in javadoc)
* @see IPath#lastSegment()
*/
@Override
public String lastSegment() {
int len = segments.length;
return len == 0 ? null : segments[len - 1];
}
/* (Intentionally not included in javadoc)
* @see IPath#makeAbsolute()
*/
@Override
public IPath makeAbsolute() {
if (isAbsolute()) {
return this;
}
RemotePath result = new RemotePath(device, segments, flags | HAS_LEADING);
//may need canonicalizing if it has leading ".." or "." segments
if (result.segmentCount() > 0) {
String first = result.segment(0);
if (first.equals("..") || first.equals(".")) { //$NON-NLS-1$ //$NON-NLS-2$
result.canonicalize();
}
}
return result;
}
/* (Intentionally not included in javadoc)
* @see IPath#makeRelative()
*/
@Override
public IPath makeRelative() {
if (!isAbsolute()) {
return this;
}
return new RemotePath(device, segments, flags & (HAS_TRAILING | IS_FOR_WINDOWS));
}
/**
* {@inheritDoc}
* @since org.eclipse.equinox.common 3.5
*/
@Override
public IPath makeRelativeTo(IPath base) {
//can't make relative if devices are not equal
if (device != base.getDevice() && (device == null || !device.equalsIgnoreCase(base.getDevice())))
return this;
int commonLength = matchingFirstSegments(base);
final int differenceLength = base.segmentCount() - commonLength;
final int newSegmentLength = differenceLength + segmentCount() - commonLength;
if (newSegmentLength == 0)
return RemotePath.EMPTY;
String[] newSegments = new String[newSegmentLength];
//add parent references for each segment different from the base
Arrays.fill(newSegments, 0, differenceLength, ".."); //$NON-NLS-1$
//append the segments of this path not in common with the base
System.arraycopy(segments, commonLength, newSegments, differenceLength, newSegmentLength - differenceLength);
return new RemotePath(null, newSegments, flags & (HAS_TRAILING | IS_FOR_WINDOWS));
}
/* (Intentionally not included in javadoc)
* @see IPath#makeUNC(boolean)
*/
@Override
public IPath makeUNC(boolean toUNC) {
// if we are already in the right form then just return
if (!(toUNC ^ isUNC()))
return this;
int newSeparators = this.flags;
if (toUNC) {
newSeparators |= HAS_LEADING | IS_UNC;
} else {
//mask out the UNC bit
newSeparators &= HAS_LEADING | HAS_TRAILING | IS_FOR_WINDOWS;
}
return new RemotePath(toUNC ? null : device, segments, newSeparators);
}
/* (Intentionally not included in javadoc)
* @see IPath#matchingFirstSegments(IPath)
*/
@Override
public int matchingFirstSegments(IPath anotherPath) {
Assert.isNotNull(anotherPath);
int anotherPathLen = anotherPath.segmentCount();
int max = Math.min(segments.length, anotherPathLen);
int count = 0;
for (int i = 0; i < max; i++) {
if (!segments[i].equals(anotherPath.segment(i))) {
return count;
}
count++;
}
return count;
}
/* (Intentionally not included in javadoc)
* @see IPath#removeFileExtension()
*/
@Override
public IPath removeFileExtension() {
String extension = getFileExtension();
if (extension == null || extension.equals("")) { //$NON-NLS-1$
return this;
}
String lastSegment = lastSegment();
int index = lastSegment.lastIndexOf(extension) - 1;
return removeLastSegments(1).append(lastSegment.substring(0, index));
}
/* (Intentionally not included in javadoc)
* @see IPath#removeFirstSegments(int)
*/
@Override
public IPath removeFirstSegments(int count) {
if (count == 0)
return this;
if (count >= segments.length) {
return new RemotePath(device, NO_SEGMENTS, flags & IS_FOR_WINDOWS);
}
Assert.isLegal(count > 0);
int newSize = segments.length - count;
String[] newSegments = new String[newSize];
System.arraycopy(this.segments, count, newSegments, 0, newSize);
//result is always a relative path
return new RemotePath(device, newSegments, flags & (HAS_TRAILING | IS_FOR_WINDOWS));
}
/* (Intentionally not included in javadoc)
* @see IPath#removeLastSegments(int)
*/
@Override
public IPath removeLastSegments(int count) {
if (count == 0)
return this;
if (count >= segments.length) {
//result will have no trailing separator
return new RemotePath(device, NO_SEGMENTS, flags & (HAS_LEADING | IS_UNC | IS_FOR_WINDOWS));
}
Assert.isLegal(count > 0);
int newSize = segments.length - count;
String[] newSegments = new String[newSize];
System.arraycopy(this.segments, 0, newSegments, 0, newSize);
return new RemotePath(device, newSegments, flags);
}
/* (Intentionally not included in javadoc)
* @see IPath#removeTrailingSeparator()
*/
@Override
public IPath removeTrailingSeparator() {
if (!hasTrailingSeparator()) {
return this;
}
return new RemotePath(device, segments, flags & (HAS_LEADING | IS_UNC | IS_FOR_WINDOWS));
}
/* (Intentionally not included in javadoc)
* @see IPath#segment(int)
*/
@Override
public String segment(int index) {
if (index >= segments.length)
return null;
return segments[index];
}
/* (Intentionally not included in javadoc)
* @see IPath#segmentCount()
*/
@Override
public int segmentCount() {
return segments.length;
}
/* (Intentionally not included in javadoc)
* @see IPath#segments()
*/
@Override
public String[] segments() {
String[] segmentCopy = new String[segments.length];
System.arraycopy(segments, 0, segmentCopy, 0, segments.length);
return segmentCopy;
}
/* (Intentionally not included in javadoc)
* @see IPath#setDevice(String)
*/
@Override
public IPath setDevice(String value) {
if (value != null) {
Assert.isTrue(value.indexOf(IPath.DEVICE_SEPARATOR) == (value.length() - 1), "Last character should be the device separator"); //$NON-NLS-1$
}
//return the receiver if the device is the same
if (value == device || (value != null && value.equals(device)))
return this;
return new RemotePath(value, segments, flags);
}
/* (Intentionally not included in javadoc)
* @see IPath#toFile()
*/
@Override
public File toFile() {
return new File(toOSString());
}
/* (Intentionally not included in javadoc)
* @see IPath#toOSString()
*/
@Override
public String toOSString() {
//Note that this method is identical to toString except
//it uses the OS file separator instead of the path separator
int resultSize = computeLength();
if (resultSize <= 0)
return EMPTY_STRING;
char FILE_SEPARATOR = File.separatorChar;
char[] result = new char[resultSize];
int offset = 0;
if (device != null) {
int size = device.length();
device.getChars(0, size, result, offset);
offset += size;
}
if ((flags & HAS_LEADING) != 0)
result[offset++] = FILE_SEPARATOR;
if ((flags & IS_UNC) != 0)
result[offset++] = FILE_SEPARATOR;
int len = segments.length - 1;
if (len >= 0) {
//append all but the last segment, with file separators
for (int i = 0; i < len; i++) {
int size = segments[i].length();
segments[i].getChars(0, size, result, offset);
offset += size;
result[offset++] = FILE_SEPARATOR;
}
//append the last segment
int size = segments[len].length();
segments[len].getChars(0, size, result, offset);
offset += size;
}
if ((flags & HAS_TRAILING) != 0)
result[offset++] = FILE_SEPARATOR;
return new String(result);
}
/* (Intentionally not included in javadoc)
* @see IPath#toPortableString()
*/
@Override
public String toPortableString() {
int resultSize = computeLength();
if (resultSize <= 0)
return EMPTY_STRING;
StringBuffer result = new StringBuffer(resultSize);
if (device != null)
result.append(device);
if ((flags & HAS_LEADING) != 0)
result.append(SEPARATOR);
if ((flags & IS_UNC) != 0)
result.append(SEPARATOR);
int len = segments.length;
//append all segments with separators
for (int i = 0; i < len; i++) {
if (segments[i].indexOf(DEVICE_SEPARATOR) >= 0)
encodeSegment(segments[i], result);
else
result.append(segments[i]);
if (i < len - 1 || (flags & HAS_TRAILING) != 0)
result.append(SEPARATOR);
}
return result.toString();
}
/* (Intentionally not included in javadoc)
* @see IPath#toString()
*/
@Override
public String toString() {
int resultSize = computeLength();
if (resultSize <= 0)
return EMPTY_STRING;
char[] result = new char[resultSize];
int offset = 0;
if (device != null) {
int size = device.length();
device.getChars(0, size, result, offset);
offset += size;
}
if ((flags & HAS_LEADING) != 0)
result[offset++] = SEPARATOR;
if ((flags & IS_UNC) != 0)
result[offset++] = SEPARATOR;
int len = segments.length - 1;
if (len >= 0) {
//append all but the last segment, with separators
for (int i = 0; i < len; i++) {
int size = segments[i].length();
segments[i].getChars(0, size, result, offset);
offset += size;
result[offset++] = SEPARATOR;
}
//append the last segment
int size = segments[len].length();
segments[len].getChars(0, size, result, offset);
offset += size;
}
if ((flags & HAS_TRAILING) != 0)
result[offset++] = SEPARATOR;
return new String(result);
}
/* (Intentionally not included in javadoc)
* @see IPath#uptoSegment(int)
*/
@Override
public IPath uptoSegment(int count) {
if (count == 0)
return new RemotePath(device, NO_SEGMENTS, flags & (HAS_LEADING | IS_UNC | IS_FOR_WINDOWS));
if (count >= segments.length)
return this;
Assert.isTrue(count > 0, "Invalid parameter to RemotePath.uptoSegment"); //$NON-NLS-1$
String[] newSegments = new String[count];
System.arraycopy(segments, 0, newSegments, 0, count);
return new RemotePath(device, newSegments, flags);
}
}
RemoteProcess.java 0000664 0000000 0000000 00000011010 12721140017 0036174 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core /*******************************************************************************
* Copyright (c) 2007 IBM Corporation 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
*
* Contributors:
* IBM Corporation - Initial API and implementation
*******************************************************************************/
package org.eclipse.remote.internal.core;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.HashMap;
import java.util.Map;
import org.eclipse.remote.core.IRemoteConnection;
import org.eclipse.remote.core.IRemoteProcess;
import org.eclipse.remote.core.IRemoteProcessBuilder;
import org.eclipse.remote.core.IRemoteProcessControlService;
/**
* Standard root class for remote processes.
*/
public class RemoteProcess extends Process implements IRemoteProcess {
private final Map, Service> servicesMap = new HashMap<>();
private final IRemoteConnection connection;
private final IRemoteProcessBuilder builder;
/**
* @since 2.0
*/
public RemoteProcess(IRemoteConnection connection, IRemoteProcessBuilder builder) {
this.connection = connection;
this.builder = builder;
}
/*
* (non-Javadoc)
*
* @see java.lang.Process#destroy()
*/
@Override
public void destroy() {
IRemoteProcessControlService controlService = getService(IRemoteProcessControlService.class);
if (controlService != null) {
controlService.destroy();
}
}
/*
* (non-Javadoc)
*
* @see java.lang.Process#exitValue()
*/
@Override
public int exitValue() {
IRemoteProcessControlService controlService = getService(IRemoteProcessControlService.class);
if (controlService != null) {
return controlService.exitValue();
}
return 0;
}
/*
* (non-Javadoc)
*
* @see java.lang.Process#getErrorStream()
*/
@Override
public InputStream getErrorStream() {
IRemoteProcessControlService controlService = getService(IRemoteProcessControlService.class);
if (controlService != null) {
return controlService.getErrorStream();
}
return null;
}
/*
* (non-Javadoc)
*
* @see java.lang.Process#getInputStream()
*/
@Override
public InputStream getInputStream() {
IRemoteProcessControlService controlService = getService(IRemoteProcessControlService.class);
if (controlService != null) {
return controlService.getInputStream();
}
return null;
}
/*
* (non-Javadoc)
*
* @see java.lang.Process#getOutputStream()
*/
@Override
public OutputStream getOutputStream() {
IRemoteProcessControlService controlService = getService(IRemoteProcessControlService.class);
if (controlService != null) {
return controlService.getOutputStream();
}
return null;
}
/**
* @since 2.0
*/
@SuppressWarnings("unchecked")
@Override
public T getService(Class service) {
T obj = (T) servicesMap.get(service);
if (obj == null) {
obj = getConnectionType().getProcessService(this, service);
if (obj != null) {
servicesMap.put(service, obj);
}
}
return obj;
}
/**
* @since 2.0
*/
@Override
public boolean hasService(Class service) {
return servicesMap.get(service.getName()) != null || getConnectionType().hasProcessService(service);
}
/*
* (non-Javadoc)
*
* @see java.lang.Process#waitFor()
*/
@Override
public int waitFor() throws InterruptedException {
IRemoteProcessControlService controlService = getService(IRemoteProcessControlService.class);
if (controlService != null) {
return controlService.waitFor();
}
return 0;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteProcess#isCompleted()
*/
@Override
public boolean isCompleted() {
IRemoteProcessControlService controlService = getService(IRemoteProcessControlService.class);
if (controlService != null) {
return controlService.isCompleted();
}
return true;
}
/**
* @since 2.0
*/
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteProcess#getRemoteConnection()
*/
@Override
public IRemoteConnection getRemoteConnection() {
return connection;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteProcess#getProcessBuilder()
*/
@Override
public IRemoteProcessBuilder getProcessBuilder() {
return builder;
}
private RemoteConnectionType getConnectionType() {
return (RemoteConnectionType) getRemoteConnection().getConnectionType();
}
}
RemoteResourceAdapterFactory.java 0000664 0000000 0000000 00000005646 12721140017 0041220 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core /*******************************************************************************
* Copyright (c) 2011 IBM 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:
* IBM - Initial API and implementation
*******************************************************************************/
package org.eclipse.remote.internal.core;
import java.util.HashMap;
import java.util.Map;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IAdapterFactory;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.Platform;
import org.eclipse.remote.core.IRemoteResource;
import org.eclipse.remote.internal.core.services.local.LocalResource;
public class RemoteResourceAdapterFactory implements IAdapterFactory {
public static final String EXTENSION_POINT_ID = "remoteResources"; //$NON-NLS-1$
public static final String ATTR_NATURE = "nature"; //$NON-NLS-1$
public static final String ATTR_CLASS = "class"; //$NON-NLS-1$
private Map fResourceFactory;
@SuppressWarnings("rawtypes")
public Object getAdapter(Object adaptableObject, Class adapterType) {
if (adapterType == IRemoteResource.class) {
if (adaptableObject instanceof IResource) {
loadExtensions();
IResource resource = (IResource) adaptableObject;
for (String nature : fResourceFactory.keySet()) {
try {
if (resource.getProject().hasNature(nature)) {
RemoteResourceFactory factory = fResourceFactory.get(nature);
if (factory != null) {
return factory.getRemoteResource(resource);
}
}
} catch (CoreException e) {
// Treat as failure
}
}
return new LocalResource(resource);
}
}
return null;
}
@SuppressWarnings("rawtypes")
public Class[] getAdapterList() {
return new Class[] { IRemoteResource.class };
}
private synchronized void loadExtensions() {
if (fResourceFactory == null) {
fResourceFactory = new HashMap();
IExtensionRegistry registry = Platform.getExtensionRegistry();
IExtensionPoint extensionPoint = registry.getExtensionPoint(RemoteCorePlugin.getUniqueIdentifier(),
EXTENSION_POINT_ID);
for (IExtension ext : extensionPoint.getExtensions()) {
final IConfigurationElement[] elements = ext.getConfigurationElements();
for (IConfigurationElement ce : elements) {
String nature = ce.getAttribute(ATTR_NATURE);
RemoteResourceFactory factory = new RemoteResourceFactory(ce);
fResourceFactory.put(nature, factory);
}
}
}
}
}
RemoteResourceFactory.java 0000664 0000000 0000000 00000002661 12721140017 0037711 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core /*******************************************************************************
* Copyright (c) 2011 IBM 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:
* IBM - Initial API and implementation
*******************************************************************************/
package org.eclipse.remote.internal.core;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.remote.core.IRemoteResource;
/**
* Factory to create an IRemoteResource
*
* @author greg
*
*/
public class RemoteResourceFactory {
private final IConfigurationElement fConfigElement;
public RemoteResourceFactory(IConfigurationElement ce) {
fConfigElement = ce;
}
/**
* Get the remote resource associated with the platform resource.
*
* @return IRemoteResource
*/
public IRemoteResource getRemoteResource(IResource resource) {
try {
IRemoteResource remoteRes = (IRemoteResource) fConfigElement
.createExecutableExtension(RemoteResourceAdapterFactory.ATTR_CLASS);
remoteRes.setResource(resource);
return remoteRes;
} catch (CoreException e) {
RemoteCorePlugin.log(e);
return null;
}
}
} RemoteServicesManager.java 0000664 0000000 0000000 00000021146 12721140017 0037647 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core /*******************************************************************************
* Copyright (c) 2015 QNX Software Systems 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
*
* Contributors:
* QNX - initial API and implementation
*******************************************************************************/
package org.eclipse.remote.internal.core;
import java.net.URI;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.preferences.InstanceScope;
import org.eclipse.equinox.security.storage.ISecurePreferences;
import org.eclipse.equinox.security.storage.SecurePreferencesFactory;
import org.eclipse.remote.core.IRemoteConnection;
import org.eclipse.remote.core.IRemoteConnectionChangeListener;
import org.eclipse.remote.core.IRemoteConnectionProviderService;
import org.eclipse.remote.core.IRemoteConnectionType;
import org.eclipse.remote.core.IRemoteServicesManager;
import org.eclipse.remote.core.RemoteConnectionChangeEvent;
import org.osgi.service.prefs.Preferences;
/**
* The implementation for the remote services manager service.
*
*/
public class RemoteServicesManager implements IRemoteServicesManager {
private static final String LOCAL_SERVICES_ID = "org.eclipse.remote.LocalServices"; //$NON-NLS-1$
// Map from id to remote services
private final Map connectionTypeMap = new HashMap<>();
// Map from URI scheme to remote services
private final Map schemeMap = new HashMap<>();
private final List listeners = new LinkedList<>();
private boolean inited;
/**
* Loads up the services extensions and then loads up the persisted connections.
* This stuff can't be done from the constructor for the manager since that's done
* in the bundle activator which is way too early. It also gives us the ability
* to override the initialization in tests
*/
protected void init() {
if (inited) {
return;
}
inited = true;
IExtensionRegistry registry = Platform.getExtensionRegistry();
IExtensionPoint point = registry.getExtensionPoint(RemoteCorePlugin.getUniqueIdentifier(), "remoteServices"); //$NON-NLS-1$
// Load up the connection types
for (IExtension ext : point.getExtensions()) {
for (IConfigurationElement ce : ext.getConfigurationElements()) {
if (ce.getName().equals("connectionType")) { //$NON-NLS-1$
RemoteConnectionType services = new RemoteConnectionType(ce, this);
connectionTypeMap.put(services.getId(), services);
String scheme = services.getScheme();
if (scheme != null) {
schemeMap.put(scheme, services);
}
}
}
}
// Load up the services
for (IExtension ext : point.getExtensions()) {
for (IConfigurationElement ce : ext.getConfigurationElements()) {
String name = ce.getName();
if (name.equals("connectionTypeService") || name.equals("connectionService") || name.equals("processService")) { //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
String id = ce.getAttribute("connectionTypeId"); //$NON-NLS-1$
RemoteConnectionType services = connectionTypeMap.get(id);
if (services != null) {
services.addService(ce);
}
}
}
}
// Init connection providers
for (IRemoteConnectionType connectionType : connectionTypeMap.values()) {
IRemoteConnectionProviderService providerService = connectionType.getService(IRemoteConnectionProviderService.class);
if (providerService != null) {
providerService.init();
}
}
}
public Preferences getPreferenceNode() {
return InstanceScope.INSTANCE.getNode(RemoteCorePlugin.getUniqueIdentifier()).node("connections"); //$NON-NLS-1$
}
public ISecurePreferences getSecurePreferenceNode() {
return SecurePreferencesFactory.getDefault().node(RemoteCorePlugin.getUniqueIdentifier()).node("connections"); //$NON-NLS-1$
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteServicesManager#getConnectionType(java.lang.String)
*/
@Override
public IRemoteConnectionType getConnectionType(String id) {
init();
return connectionTypeMap.get(id);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteServicesManager#getConnectionType(java.net.URI)
*/
@Override
public IRemoteConnectionType getConnectionType(URI uri) {
init();
return schemeMap.get(uri.getScheme());
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteServicesManager#getLocalConnectionType()
*/
@Override
public IRemoteConnectionType getLocalConnectionType() {
return getConnectionType(LOCAL_SERVICES_ID);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteServicesManager#getAllConnectionTypes()
*/
@Override
public List getAllConnectionTypes() {
init();
return new ArrayList(connectionTypeMap.values());
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteServicesManager#getConnectionTypesSupporting(java.lang.Class[])
*/
@Override
@SafeVarargs
public final List getConnectionTypesSupporting(Class... services) {
List connTypes = new ArrayList();
for (IRemoteConnectionType connType : getAllConnectionTypes()) {
for (Class service : services) {
if (connType.hasConnectionService(service)) {
connTypes.add(connType);
break;
}
}
}
return connTypes;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteServicesManager#getConnectionTypesByService(java.lang.Class[])
*/
@Override
@SafeVarargs
public final List getConnectionTypesByService(Class... services) {
List connTypes = new ArrayList();
for (IRemoteConnectionType connType : getAllConnectionTypes()) {
for (Class service : services) {
if (!connType.hasService(service)) {
connTypes.add(connType);
break;
}
}
}
return connTypes;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteServicesManager#getRemoteConnectionTypes()
*/
@Override
public List getRemoteConnectionTypes() {
init();
List connTypes = new ArrayList<>(connectionTypeMap.values().size() - 1);
IRemoteConnectionType localServices = getLocalConnectionType();
for (IRemoteConnectionType s : connectionTypeMap.values()) {
if (!s.equals(localServices)) {
connTypes.add(s);
}
}
return connTypes;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteServicesManager#getAllRemoteConnections()
*/
@Override
public List getAllRemoteConnections() {
List connections = new ArrayList<>();
for (IRemoteConnectionType connType : getAllConnectionTypes()) {
connections.addAll(connType.getConnections());
}
return connections;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteServicesManager#addRemoteConnectionChangeListener(org.eclipse.remote.core.
* IRemoteConnectionChangeListener)
*/
@Override
public void addRemoteConnectionChangeListener(IRemoteConnectionChangeListener listener) {
synchronized (listeners) {
listeners.add(listener);
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteServicesManager#removeRemoteConnectionChangeListener(org.eclipse.remote.core.
* IRemoteConnectionChangeListener)
*/
@Override
public void removeRemoteConnectionChangeListener(IRemoteConnectionChangeListener listener) {
synchronized (listeners) {
listeners.remove(listener);
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteServicesManager#fireRemoteConnectionChangeEvent(org.eclipse.remote.core.
* RemoteConnectionChangeEvent)
*/
@Override
public void fireRemoteConnectionChangeEvent(RemoteConnectionChangeEvent event) {
List iListeners;
synchronized (listeners) {
iListeners = new ArrayList<>(listeners);
}
for (IRemoteConnectionChangeListener listener : iListeners) {
listener.connectionChanged(event);
}
}
}
launch/ 0000775 0000000 0000000 00000000000 12721140017 0034020 5 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core RemoteLaunchConfigService.java 0000664 0000000 0000000 00000004602 12721140017 0041722 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core/launch package org.eclipse.remote.internal.core.launch;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.preferences.InstanceScope;
import org.eclipse.debug.core.ILaunchConfiguration;
import org.eclipse.debug.core.ILaunchConfigurationType;
import org.eclipse.remote.core.IRemoteConnection;
import org.eclipse.remote.core.IRemoteConnectionType;
import org.eclipse.remote.core.IRemoteServicesManager;
import org.eclipse.remote.core.launch.IRemoteLaunchConfigService;
import org.eclipse.remote.internal.core.RemoteCorePlugin;
import org.osgi.service.prefs.Preferences;
public class RemoteLaunchConfigService implements IRemoteLaunchConfigService {
private static final String REMOTE_LAUNCH_CONFIG = "remoteLaunchConfig"; //$NON-NLS-1$
private static final String REMOTE_LAUNCH_TYPE = "remoteLaunchType"; //$NON-NLS-1$
private Preferences getPreferences(String node) {
return InstanceScope.INSTANCE.getNode(RemoteCorePlugin.getUniqueIdentifier()).node(node);
}
private IRemoteConnection getRemoteConnection(String remoteId) {
if (remoteId == null) {
return null;
}
String[] ids = remoteId.split(":"); //$NON-NLS-1$
if (ids.length < 2) {
return null;
}
IRemoteServicesManager manager = RemoteCorePlugin.getService(IRemoteServicesManager.class);
IRemoteConnectionType connectionType = manager.getConnectionType(ids[0]);
if (connectionType == null) {
return null;
}
return connectionType.getConnection(ids[1]);
}
@Override
public void setActiveConnection(ILaunchConfiguration launchConfig, IRemoteConnection connection) {
String remoteId = connection.getConnectionType().getId() + ":" + connection.getName(); //$NON-NLS-1$
getPreferences(REMOTE_LAUNCH_CONFIG).put(launchConfig.getName(), remoteId);
try {
getPreferences(REMOTE_LAUNCH_TYPE).put(launchConfig.getType().getIdentifier(), remoteId);
} catch (CoreException e) {
RemoteCorePlugin.log(e.getStatus());
}
}
@Override
public IRemoteConnection getActiveConnection(ILaunchConfiguration launchConfig) {
String remoteId = getPreferences(REMOTE_LAUNCH_CONFIG).get(launchConfig.getName(), null);
return getRemoteConnection(remoteId);
}
@Override
public IRemoteConnection getLastActiveConnection(ILaunchConfigurationType launchConfigType) {
String remoteId = getPreferences(REMOTE_LAUNCH_TYPE).get(launchConfigType.getIdentifier(), null);
return getRemoteConnection(remoteId);
}
}
messages/ 0000775 0000000 0000000 00000000000 12721140017 0034355 5 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core Messages.java 0000664 0000000 0000000 00000001125 12721140017 0036766 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core/messages package org.eclipse.remote.internal.core.messages;
import org.eclipse.osgi.util.NLS;
public class Messages extends NLS {
private static final String BUNDLE_NAME = "org.eclipse.remote.internal.core.messages.messages"; //$NON-NLS-1$
public static String LocalConnection_1;
public static String LocalConnection_2;
public static String RemoteServicesProxy_0;
public static String RemoteServicesProxy_1;
public static String Unable_to_create_new_local_connections;
static {
// initialize resource bundle
NLS.initializeMessages(BUNDLE_NAME, Messages.class);
}
private Messages() {
}
}
messages.properties 0000664 0000000 0000000 00000000433 12721140017 0040302 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core/messages LocalConnection_1=localhost
LocalConnection_2=Port forwarding not supported
Unable_to_create_new_local_connections=Unable to create new local connections
RemoteServicesProxy_0=Missing {0} attribute
RemoteServicesProxy_1=Failed to instantiate factory: {0} in type: {1} in plugin: {2}
preferences/ 0000775 0000000 0000000 00000000000 12721140017 0035047 5 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core PreferenceInitializer.java 0000664 0000000 0000000 00000002072 12721140017 0042175 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core/preferences /*******************************************************************************
* Copyright (c) 2012 IBM Corporation 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
*
* Contributors:
* IBM - Initial API and implementation
*******************************************************************************/
package org.eclipse.remote.internal.core.preferences;
import org.eclipse.core.runtime.preferences.AbstractPreferenceInitializer;
import org.eclipse.remote.core.IRemotePreferenceConstants;
/**
* Class used to initialize default preference values.
*
* @since 6.0
*/
public class PreferenceInitializer extends AbstractPreferenceInitializer {
@Override
public void initializeDefaultPreferences() {
Preferences.setDefaultString(IRemotePreferenceConstants.PREF_CONNECTION_TYPE_ID, "org.eclipse.remote.JSch"); //$NON-NLS-1$
}
}
Preferences.java 0000664 0000000 0000000 00000036701 12721140017 0040162 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core/preferences /*******************************************************************************
* Copyright (c) 2011 IBM Corporation 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
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.remote.internal.core.preferences;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.preferences.DefaultScope;
import org.eclipse.core.runtime.preferences.IEclipsePreferences;
import org.eclipse.core.runtime.preferences.IEclipsePreferences.IPreferenceChangeListener;
import org.eclipse.core.runtime.preferences.IScopeContext;
import org.eclipse.core.runtime.preferences.InstanceScope;
import org.eclipse.remote.internal.core.RemoteCorePlugin;
import org.osgi.service.prefs.BackingStoreException;
/**
* Convenience class to facilitate using the new {@link IEclipsePreferences} story. Adapted from
* org.eclipse.debug.internal.core.Preferences.
*
* @since 5.0
* @noinstantiate This class is not intended to be instantiated by clients.
*/
public final class Preferences {
private static final IScopeContext[] contexts = new IScopeContext[] { DefaultScope.INSTANCE, InstanceScope.INSTANCE };
private static final int DEFAULT_CONTEXT = 0;
private static final int INSTANCE_CONTEXT = 1;
private static final String fQualifier = RemoteCorePlugin.getUniqueIdentifier();
/**
* Adds the given preference listener to the {@link DefaultScope} and the {@link InstanceScope}
*
* @param listener
*/
public static void addPreferenceChangeListener(IPreferenceChangeListener listener) {
contexts[DEFAULT_CONTEXT].getNode(fQualifier).addPreferenceChangeListener(listener);
contexts[INSTANCE_CONTEXT].getNode(fQualifier).addPreferenceChangeListener(listener);
}
/**
* Returns whether the named preference is know in the preference store.
*
* @param name
* @return
*/
public static boolean contains(String name) {
return (contexts[INSTANCE_CONTEXT].getNode(fQualifier).get(name, null) != null || contexts[DEFAULT_CONTEXT].getNode(
fQualifier).get(name, null) != null);
}
/**
* Returns the value in the preference store for the given key. If the key
* is not defined then return the default value. Use the canonical scope
* lookup order for finding the preference value.
*
* @param key
* @param defaultvalue
*
* @return the value of the preference or the given default value
*/
public static boolean getBoolean(String key) {
return Platform.getPreferencesService().getBoolean(fQualifier, key, false, null);
}
/**
* Returns the value in the preference store for the given key. If the key
* is not defined then return the default value. Use the canonical scope
* lookup order for finding the preference value.
*
* @param key
* @param defaultvalue
*
* @return the value of the preference or the given default value
*/
public static byte[] getByteArray(String key) {
return Platform.getPreferencesService().getByteArray(fQualifier, key, null, null);
}
/**
* Returns the default boolean value stored in the {@link DefaultScope} for
* the given key or the specified default value if the key does not appear
* in the {@link DefaultScope}
*
* @param key
* @param defaultvalue
*
* @return the boolean value set in the {@link DefaultScope} for the given
* key, or the specified default value.
*/
public static synchronized boolean getDefaultBoolean(String key, boolean defaultvalue) {
return contexts[DEFAULT_CONTEXT].getNode(fQualifier).getBoolean(key, defaultvalue);
}
/**
* Returns the default byte array value stored in the {@link DefaultScope} for the given key or the specified default value if
* the key does not
* appear in the {@link DefaultScope}
*
* @param key
* @param defaultvalue
*
* @return the byte array value set in the {@link DefaultScope} for the
* given key, or the specified default value.
*/
public static synchronized byte[] getDefaultByteArray(String key, byte[] defaultvalue) {
return contexts[DEFAULT_CONTEXT].getNode(fQualifier).getByteArray(key, defaultvalue);
}
/**
* Returns the default double value stored in the {@link DefaultScope} for
* the given key or the specified default value if the key does not appear
* in the {@link DefaultScope}
*
* @param key
* @param defaultvalue
*
* @return the double value set in the {@link DefaultScope} for the given
* key, or the specified default value.
*/
public static synchronized double getDefaultDouble(String key, double defaultvalue) {
return contexts[DEFAULT_CONTEXT].getNode(fQualifier).getDouble(key, defaultvalue);
}
/**
* Returns the default float value stored in the {@link DefaultScope} for
* the given key or the specified default value if the key does not appear
* in the {@link DefaultScope}
*
* @param key
* @param defaultvalue
*
* @return the float value set in the {@link DefaultScope} for the given
* key, or the specified default value.
*/
public static synchronized float getDefaultFloat(String key, float defaultvalue) {
return contexts[DEFAULT_CONTEXT].getNode(fQualifier).getFloat(key, defaultvalue);
}
/**
* Returns the default integer value stored in the {@link DefaultScope} for
* the given key or the specified default value if the key does not appear
* in the {@link DefaultScope}
*
* @param key
* @param defaultvalue
*
* @return the integer value set in the {@link DefaultScope} for the given
* key, or the specified default value.
*/
public static synchronized int getDefaultInt(String key, int defaultvalue) {
return contexts[DEFAULT_CONTEXT].getNode(fQualifier).getInt(key, defaultvalue);
}
/**
* Returns the default long value stored in the {@link DefaultScope} for the
* given key or the specified default value if the key does not appear in
* the {@link DefaultScope}
*
* @param key
* @param defaultvalue
*
* @return the long value set in the {@link DefaultScope} for the given key,
* or the specified default value.
*/
public static synchronized long getDefaultLong(String key, long defaultvalue) {
return contexts[DEFAULT_CONTEXT].getNode(fQualifier).getLong(key, defaultvalue);
}
/**
* Returns the default string value stored in the {@link DefaultScope} for
* the given key or the specified default value if the key does not appear
* in the {@link DefaultScope}
*
* @param key
* @param defaultvalue
*
* @return the string value set in the {@link DefaultScope} for the given
* key, or the specified default value.
*/
public static synchronized String getDefaultString(String key, String defaultvalue) {
return contexts[DEFAULT_CONTEXT].getNode(fQualifier).get(key, defaultvalue);
}
/**
* Returns the value in the preference store for the given key. If the key
* is not defined then return the default value. Use the canonical scope
* lookup order for finding the preference value.
*
* @param key
* @param defaultvalue
*
* @return the value of the preference or the given default value
*/
public static double getDouble(String key) {
return Platform.getPreferencesService().getDouble(fQualifier, key, 0.0, null);
}
/**
* Returns the value in the preference store for the given key. If the key
* is not defined then return the default value. Use the canonical scope
* lookup order for finding the preference value.
*
* @param fQualifier
* @param key
* @param defaultvalue
*
* @return the value of the preference or the given default value
*/
public static float getFloat(String key) {
return Platform.getPreferencesService().getFloat(fQualifier, key, 0.0f, null);
}
/**
* Returns the value in the preference store for the given key. If the key
* is not defined then return the default value. Use the canonical scope
* lookup order for finding the preference value.
*
* @param fQualifier
* @param key
* @param defaultvalue
*
* @return the value of the preference or the given default value
*/
public static int getInt(String key) {
return Platform.getPreferencesService().getInt(fQualifier, key, 0, null);
}
/**
* Returns the value in the preference store for the given key. If the key
* is not defined then return the default value. Use the canonical scope
* lookup order for finding the preference value.
*
* @param key
* @param defaultvalue
*
* @return the value of the preference or the given default value
*/
public static long getLong(String key) {
return Platform.getPreferencesService().getLong(fQualifier, key, 0L, null);
}
/**
* Returns the value in the preference store for the given key. If the key
* is not defined then return the default value. Use the canonical scope
* lookup order for finding the preference value.
*
* @param key
* @param defaultvalue
*
* @return the value of the preference or the given default value
*/
public static String getString(String key) {
return Platform.getPreferencesService().getString(fQualifier, key, null, null);
}
/**
* Returns true if the named preference has the default value.
*
* @param name
* @return
*/
public static boolean isDefault(String name) {
String defVal = contexts[DEFAULT_CONTEXT].getNode(fQualifier).get(name, null);
if (defVal != null) {
String val = contexts[INSTANCE_CONTEXT].getNode(fQualifier).get(name, null);
return (val != null && val.equals(defVal));
}
return false;
}
/**
* Removes the given preference listener from the {@link DefaultScope} and
* the {@link InstanceScope}
*
* @param listener
*/
public static void removePreferenceChangeListener(IPreferenceChangeListener listener) {
contexts[DEFAULT_CONTEXT].getNode(fQualifier).removePreferenceChangeListener(listener);
contexts[INSTANCE_CONTEXT].getNode(fQualifier).removePreferenceChangeListener(listener);
}
/**
* Save the preferences for the given plugin identifier. It should be noted
* that all pending preference changes will be flushed with this method.
*/
public static synchronized void savePreferences() {
try {
contexts[DEFAULT_CONTEXT].getNode(fQualifier).flush();
contexts[INSTANCE_CONTEXT].getNode(fQualifier).flush();
} catch (BackingStoreException bse) {
RemoteCorePlugin.log(bse);
}
}
/**
* Sets a boolean preference in the {@link InstanceScope}.
*
* @param key
* the key
* @param value
* the value
*/
public static synchronized void setBoolean(String key, boolean value) {
contexts[INSTANCE_CONTEXT].getNode(fQualifier).putBoolean(key, value);
}
/**
* Sets a byte array preference in the {@link InstanceScope}.
*
* @param key
* the key
* @param value
* the value
*/
public static synchronized void setByteArray(String key, byte[] value) {
contexts[INSTANCE_CONTEXT].getNode(fQualifier).putByteArray(key, value);
}
/**
* Sets a boolean in the {@link DefaultScope}
*
* @param key
* the key
* @param value
* the new value
*/
public static synchronized void setDefaultBoolean(String key, boolean value) {
contexts[DEFAULT_CONTEXT].getNode(fQualifier).putBoolean(key, value);
}
/**
* Sets a byte array in the {@link DefaultScope}
*
* @param key
* the key
* @param value
* the new value
*/
public static synchronized void setDefaultByteArray(String key, byte[] value) {
contexts[DEFAULT_CONTEXT].getNode(fQualifier).putByteArray(key, value);
}
/**
* Sets a double in the {@link DefaultScope}
*
* @param key
* the key
* @param value
* the new value
*/
public static synchronized void setDefaultDouble(String key, double value) {
contexts[DEFAULT_CONTEXT].getNode(fQualifier).putDouble(key, value);
}
/**
* Sets a float in the {@link DefaultScope}
*
* @param key
* the key
* @param value
* the new value
*/
public static synchronized void setDefaultFloat(String key, float value) {
contexts[DEFAULT_CONTEXT].getNode(fQualifier).putFloat(key, value);
}
/**
* Sets a integer in the {@link DefaultScope}
*
* @param key
* the key
* @param value
* the new value
*/
public static synchronized void setDefaultInt(String key, int value) {
contexts[DEFAULT_CONTEXT].getNode(fQualifier).putInt(key, value);
}
/**
* Sets a long in the {@link DefaultScope}
*
* @param key
* the key
* @param value
* the new value
*/
public static synchronized void setDefaultLong(String key, long value) {
contexts[DEFAULT_CONTEXT].getNode(fQualifier).putLong(key, value);
}
/**
* Sets a string in the {@link DefaultScope}
*
* @param key
* the key
* @param value
* the new value
*/
public static synchronized void setDefaultString(String key, String value) {
contexts[DEFAULT_CONTEXT].getNode(fQualifier).put(key, value);
}
/**
* Sets a double preference in the {@link InstanceScope}.
*
* @param key
* the key
* @param value
* the value
*/
public static synchronized void setDouble(String key, double value) {
contexts[INSTANCE_CONTEXT].getNode(fQualifier).putDouble(key, value);
}
/**
* Sets a float preference in the {@link InstanceScope}.
*
* @param key
* the key
* @param value
* the value
*/
public static synchronized void setFloat(String key, float value) {
contexts[INSTANCE_CONTEXT].getNode(fQualifier).putFloat(key, value);
}
/**
* Sets a integer preference in the {@link InstanceScope}.
*
* @param key
* the key
* @param value
* the value
*/
public static synchronized void setInt(String key, int value) {
contexts[INSTANCE_CONTEXT].getNode(fQualifier).putInt(key, value);
}
/**
* Sets a long preference in the {@link InstanceScope}.
*
* @param key
* the key
* @param value
* the value
*/
public static synchronized void setLong(String key, long value) {
contexts[INSTANCE_CONTEXT].getNode(fQualifier).putLong(key, value);
}
/**
* Sets a string preference in the {@link InstanceScope}.
*
* @param key
* the key
* @param value
* the value
*/
public static synchronized void setString(String key, String value) {
contexts[INSTANCE_CONTEXT].getNode(fQualifier).put(key, value);
}
/**
* Sets the given preference to its default value. This is done by removing
* any set value from the {@link InstanceScope}. Has no effect if the given
* key is null.
*
* @param key
* the key for the preference
*/
public static synchronized void setToDefault(String key) {
if (key != null) {
contexts[INSTANCE_CONTEXT].getNode(fQualifier).remove(key);
}
}
/**
* Constructor
*/
private Preferences() {
// no direct instantiation
}
}
services/ 0000775 0000000 0000000 00000000000 12721140017 0034371 5 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core local/ 0000775 0000000 0000000 00000000000 12721140017 0035463 5 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core/services LocalCommandShellService.java 0000664 0000000 0000000 00000004476 12721140017 0043203 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core/services/local /*******************************************************************************
* Copyright (c) 2015 QNX Software Systems 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
*
* Contributors:
* QNX - initial API and implementation
*******************************************************************************/
package org.eclipse.remote.internal.core.services.local;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.eclipse.core.runtime.Platform;
import org.eclipse.remote.core.IRemoteCommandShellService;
import org.eclipse.remote.core.IRemoteConnection;
import org.eclipse.remote.core.IRemoteConnection.Service;
import org.eclipse.remote.core.IRemoteProcess;
import org.eclipse.remote.core.IRemoteProcessBuilder;
import org.eclipse.remote.core.IRemoteProcessService;
public class LocalCommandShellService implements IRemoteCommandShellService {
private final IRemoteConnection connection;
public LocalCommandShellService(IRemoteConnection connection) {
this.connection = connection;
}
public static class Factory implements IRemoteCommandShellService.Factory {
@SuppressWarnings("unchecked")
@Override
public T getService(IRemoteConnection remoteConnection, Class service) {
if (service.equals(IRemoteCommandShellService.class)) {
return (T) new LocalCommandShellService(remoteConnection);
}
return null;
}
}
@Override
public IRemoteConnection getRemoteConnection() {
return connection;
}
@SuppressWarnings("nls")
@Override
public IRemoteProcess getCommandShell(int flags) throws IOException {
IRemoteProcessService procService = connection.getService(IRemoteProcessService.class);
String[] command;
if (Platform.getOS().equals(Platform.OS_WIN32)) {
command = new String[] { "cmd" };
} else {
List list = new ArrayList<>(Arrays.asList(System.getenv("SHELL").split("\\s+")));
list.add("-l");
command = list.toArray(new String[list.size()]);
}
IRemoteProcessBuilder builder = procService.getProcessBuilder(command);
return builder.start(IRemoteProcessBuilder.ALLOCATE_PTY);
}
}
LocalConnectionHostService.java 0000664 0000000 0000000 00000005004 12721140017 0043556 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core/services/local /*******************************************************************************
* Copyright (c) 2007 IBM Corporation 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
*
* Contributors:
* IBM Corporation - Initial API and implementation
*******************************************************************************/
package org.eclipse.remote.internal.core.services.local;
import java.net.InetAddress;
import java.net.UnknownHostException;
import org.eclipse.remote.core.IRemoteConnection;
import org.eclipse.remote.core.IRemoteConnection.Service;
import org.eclipse.remote.core.IRemoteConnectionHostService;
public class LocalConnectionHostService implements IRemoteConnectionHostService {
private final IRemoteConnection connection;
public LocalConnectionHostService(IRemoteConnection connection) {
this.connection = connection;
}
public static class Factory implements IRemoteConnectionHostService.Factory {
@SuppressWarnings("unchecked")
@Override
public T getService(IRemoteConnection remoteConnection, Class service) {
if (service.equals(IRemoteConnectionHostService.class)) {
return (T) new LocalConnectionHostService(remoteConnection);
}
return null;
}
}
@Override
public IRemoteConnection getRemoteConnection() {
return this.connection;
}
@Override
public String getHostname() {
try {
return InetAddress.getLocalHost().getHostName();
} catch (UnknownHostException e) {
return "unknown"; //$NON-NLS-1$
}
}
@Override
public int getPort() {
return 0;
}
@Override
public int getTimeout() {
return 0;
}
@Override
public boolean useLoginShell() {
return true;
}
@Override
public String getUsername() {
return System.getProperty("user.name"); //$NON-NLS-1$
}
@Override
public void setHostname(String hostname) {
// Ignored
}
@Override
public void setPassphrase(String passphrase) {
// Ignored
}
@Override
public void setPassword(String password) {
// Ignored
}
@Override
public void setPort(int port) {
// Ignored
}
@Override
public void setTimeout(int timeout) {
// Ignored
}
@Override
public void setUseLoginShell(boolean useLogingShell) {
// Ignored
}
@Override
public void setUsePassword(boolean usePassword) {
// Ignored
}
@Override
public void setUsername(String username) {
// Ignored
}
}
LocalConnectionPropertyService.java 0000664 0000000 0000000 00000004023 12721140017 0044465 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core/services/local /*******************************************************************************
* Copyright (c) 2015 QNX Software Systems 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
*
* Contributors:
* QNX - initial API and implementation
*******************************************************************************/
package org.eclipse.remote.internal.core.services.local;
import org.eclipse.remote.core.IRemoteConnection;
import org.eclipse.remote.core.IRemoteConnection.Service;
import org.eclipse.remote.core.IRemoteConnectionPropertyService;
import org.eclipse.remote.internal.core.RemoteCorePlugin;
public class LocalConnectionPropertyService implements IRemoteConnectionPropertyService {
private final IRemoteConnection connection;
public LocalConnectionPropertyService(IRemoteConnection connection) {
this.connection = connection;
}
public static class Factory implements IRemoteConnectionPropertyService.Factory {
@SuppressWarnings("unchecked")
@Override
public T getService(IRemoteConnection remoteConnection, Class service) {
if (service.equals(IRemoteConnectionPropertyService.class)) {
return (T) new LocalConnectionPropertyService(remoteConnection);
}
return null;
}
}
@Override
public IRemoteConnection getRemoteConnection() {
return connection;
}
@Override
public String getProperty(String key) {
switch (key) {
case IRemoteConnection.OS_NAME_PROPERTY:
return RemoteCorePlugin.getDefault().getBundle().getBundleContext().getProperty("osgi.os"); //$NON-NLS-1$
case IRemoteConnection.OS_ARCH_PROPERTY:
return RemoteCorePlugin.getDefault().getBundle().getBundleContext().getProperty("osgi.arch"); //$NON-NLS-1$
case IRemoteConnection.LOCALE_CHARMAP_PROPERTY:
return System.getProperty("file.encoding"); //$NON-NLS-1$
}
return System.getProperty(key);
}
}
LocalConnectionProviderService.java 0000664 0000000 0000000 00000003724 12721140017 0044442 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core/services/local /*******************************************************************************
* Copyright (c) 2015 QNX Software Systems 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
*
* Contributors:
* QNX - initial API and implementation
*******************************************************************************/
package org.eclipse.remote.internal.core.services.local;
import org.eclipse.remote.core.IRemoteConnectionProviderService;
import org.eclipse.remote.core.IRemoteConnectionType;
import org.eclipse.remote.core.IRemoteConnectionType.Service;
import org.eclipse.remote.core.exception.RemoteConnectionException;
import org.eclipse.remote.internal.core.RemoteCorePlugin;
public class LocalConnectionProviderService implements IRemoteConnectionProviderService {
private static final String localConnectionName = Messages.LocalConnectionProviderService_LocalConnectionName;
private IRemoteConnectionType connectionType;
public static class Factory implements IRemoteConnectionType.Service.Factory {
@SuppressWarnings("unchecked")
@Override
public T getService(IRemoteConnectionType connectionType, Class service) {
if (service.equals(IRemoteConnectionProviderService.class)) {
return (T) new LocalConnectionProviderService(connectionType);
}
return null;
}
}
public LocalConnectionProviderService(IRemoteConnectionType connectionType) {
this.connectionType = connectionType;
}
@Override
public void init() {
if (connectionType.getConnections().isEmpty()) {
try {
connectionType.newConnection(localConnectionName).save();
} catch (RemoteConnectionException e) {
RemoteCorePlugin.log(e.getStatus());
}
}
}
@Override
public IRemoteConnectionType getConnectionType() {
return connectionType;
}
}
LocalFileService.java 0000664 0000000 0000000 00000004626 12721140017 0041511 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core/services/local /*******************************************************************************
* Copyright (c) 2007 IBM Corporation 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
*
* Contributors:
* IBM Corporation - Initial API and implementation
*******************************************************************************/
package org.eclipse.remote.internal.core.services.local;
import java.net.URI;
import org.eclipse.core.filesystem.EFS;
import org.eclipse.core.filesystem.IFileStore;
import org.eclipse.core.filesystem.URIUtil;
import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Path;
import org.eclipse.remote.core.IRemoteConnection;
import org.eclipse.remote.core.IRemoteConnection.Service;
import org.eclipse.remote.core.IRemoteFileService;
import org.eclipse.remote.core.IRemoteProcessService;
public class LocalFileService implements IRemoteFileService {
private final IRemoteConnection connection;
public LocalFileService(IRemoteConnection connection) {
this.connection = connection;
}
public static class Factory implements IRemoteFileService.Factory {
@SuppressWarnings("unchecked")
@Override
public T getService(IRemoteConnection remoteConnection, Class service) {
if (IRemoteFileService.class.equals(service)) {
return (T) new LocalFileService(remoteConnection);
}
return null;
}
}
@Override
public IRemoteConnection getRemoteConnection() {
return connection;
}
@Override
public String getDirectorySeparator() {
return System.getProperty("file.separator", "/"); //$NON-NLS-1$ //$NON-NLS-2$
}
@Override
public IFileStore getResource(String path) {
return EFS.getLocalFileSystem().getStore(Path.fromOSString(path));
}
@Override
public String getBaseDirectory() {
return connection.getService(IRemoteProcessService.class).getWorkingDirectory();
}
@Override
public void setBaseDirectory(String path) {
connection.getService(IRemoteProcessService.class).setWorkingDirectory(path);
}
@Override
public String toPath(URI uri) {
return URIUtil.toPath(uri).toString();
}
@Override
public URI toURI(IPath path) {
return URIUtil.toURI(path);
}
@Override
public URI toURI(String path) {
return URIUtil.toURI(path);
}
}
LocalProcess.java 0000664 0000000 0000000 00000013724 12721140017 0040726 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core/services/local /*******************************************************************************
* Copyright (c) 2007 IBM Corporation 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
*
* Contributors:
* IBM Corporation - Initial API and implementation
*******************************************************************************/
package org.eclipse.remote.internal.core.services.local;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PipedInputStream;
import java.io.PipedOutputStream;
import org.eclipse.cdt.utils.pty.PTY;
import org.eclipse.remote.core.IRemoteProcess;
import org.eclipse.remote.core.IRemoteProcessControlService;
import org.eclipse.remote.core.IRemoteProcessTerminalService;
public class LocalProcess implements IRemoteProcessControlService, IRemoteProcessTerminalService {
private static int refCount = 0;
private final IRemoteProcess remoteProcess;
private final Process localProcess;
private final PTY pty;
private int width, height;
private InputStream procStdout;
private InputStream procStderr;
private Thread stdoutReader;
private Thread stderrReader;
private final Thread completedChecker;
private volatile boolean isCompleted;
public static class Factory implements IRemoteProcess.Service.Factory {
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteProcess.Service.Factory#getService(org.eclipse.remote.core.IRemoteProcess,
* java.lang.Class)
*/
@SuppressWarnings("unchecked")
@Override
public T getService(IRemoteProcess remoteProcess, Class service) {
// This little trick creates an instance of this class
// then for each interface it implements, it returns the same object.
// This works because the connection caches the service so only one gets created.
// As a side effect, it makes this class a service too which can be used
// by the this plug-in
if (LocalProcess.class.equals(service)) {
return (T) new LocalProcess(remoteProcess);
}
if (IRemoteProcessControlService.class.equals(service)) {
return (T) remoteProcess.getService(LocalProcess.class);
}
if (IRemoteProcessTerminalService.class.equals(service)) {
return (T) remoteProcess.getService(LocalProcess.class);
}
return null;
}
}
/**
* Thread to merge stdout and stderr. Keeps refcount so that output stream
* is not closed too early.
*
*/
private class ProcOutputMerger implements Runnable {
private final static int BUF_SIZE = 8192;
private final InputStream input;
private final OutputStream output;
public ProcOutputMerger(InputStream input, OutputStream output) {
this.input = input;
this.output = output;
synchronized (this.output) {
refCount++;
}
}
@Override
public void run() {
int len;
byte b[] = new byte[BUF_SIZE];
try {
while ((len = input.read(b)) > 0) {
output.write(b, 0, len);
}
} catch (IOException e) {
// Ignore
}
synchronized (output) {
if (--refCount == 0) {
try {
output.close();
} catch (IOException e) {
// Ignore
}
}
}
}
}
public class NullInputStream extends InputStream {
@Override
public int read() throws IOException {
return -1;
}
@Override
public int available() {
return 0;
}
}
public LocalProcess(IRemoteProcess process) {
remoteProcess = process;
LocalProcessBuilder builder = (LocalProcessBuilder) process.getProcessBuilder();
localProcess = builder.getProcess();
pty = builder.getPty();
try {
if (process.getProcessBuilder().redirectErrorStream()) {
PipedOutputStream pipedOutput = new PipedOutputStream();
procStderr = new NullInputStream();
procStdout = new PipedInputStream(pipedOutput);
stderrReader = new Thread(new ProcOutputMerger(localProcess.getErrorStream(), pipedOutput));
stdoutReader = new Thread(new ProcOutputMerger(localProcess.getInputStream(), pipedOutput));
stderrReader.start();
stdoutReader.start();
} else {
procStderr = localProcess.getErrorStream();
procStdout = localProcess.getInputStream();
}
} catch (IOException e) {
localProcess.destroy();
}
completedChecker = new Thread(new Runnable() {
@Override
public void run() {
while (!isCompleted) {
try {
localProcess.waitFor();
} catch (InterruptedException e) {
continue;
}
isCompleted = true;
}
}
});
completedChecker.start();
}
/*
* (non-Javadoc)
*
* @see java.lang.Process#destroy()
*/
@Override
public void destroy() {
localProcess.destroy();
}
/*
* (non-Javadoc)
*
* @see java.lang.Process#exitValue()
*/
@Override
public int exitValue() {
return localProcess.exitValue();
}
/*
* (non-Javadoc)
*
* @see java.lang.Process#getErrorStream()
*/
@Override
public InputStream getErrorStream() {
return procStderr;
}
/*
* (non-Javadoc)
*
* @see java.lang.Process#getInputStream()
*/
@Override
public InputStream getInputStream() {
return procStdout;
}
/*
* (non-Javadoc)
*
* @see java.lang.Process#getOutputStream()
*/
@Override
public OutputStream getOutputStream() {
return localProcess.getOutputStream();
}
/*
* (non-Javadoc)
*
* @see java.lang.Process#waitFor()
*/
@Override
public int waitFor() throws InterruptedException {
return localProcess.waitFor();
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.RemoteProcess#isCompleted()
*/
@Override
public boolean isCompleted() {
return isCompleted;
}
@Override
public IRemoteProcess getRemoteProcess() {
return remoteProcess;
}
@Override
public void setTerminalSize(int cols, int rows, int pwidth, int pheight) {
if (pty != null && (width != cols || height != rows)) {
width = cols;
height = rows;
pty.setTerminalSize(width, height);
}
}
}
LocalProcessBuilder.java 0000664 0000000 0000000 00000014247 12721140017 0042236 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core/services/local /*******************************************************************************
* Copyright (c) 2007, 2010 IBM Corporation 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
*
* Contributors:
* IBM Corporation - Initial API and implementation
*******************************************************************************/
package org.eclipse.remote.internal.core.services.local;
import java.io.File;
import java.io.IOException;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import org.eclipse.cdt.utils.pty.PTY;
import org.eclipse.cdt.utils.pty.PTY.Mode;
import org.eclipse.cdt.utils.spawner.ProcessFactory;
import org.eclipse.core.filesystem.EFS;
import org.eclipse.core.filesystem.IFileStore;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.IExtensionPoint;
import org.eclipse.core.runtime.IExtensionRegistry;
import org.eclipse.core.runtime.NullProgressMonitor;
import org.eclipse.core.runtime.Path;
import org.eclipse.core.runtime.Platform;
import org.eclipse.remote.core.AbstractRemoteProcessBuilder;
import org.eclipse.remote.core.IProcessFactory;
import org.eclipse.remote.core.IRemoteConnection;
import org.eclipse.remote.core.IRemoteProcess;
import org.eclipse.remote.core.IRemoteProcessBuilder;
import org.eclipse.remote.internal.core.RemoteCorePlugin;
import org.eclipse.remote.internal.core.RemoteProcess;
public class LocalProcessBuilder extends AbstractRemoteProcessBuilder {
private static final String EXTENSION_POINT_ID = "processFactory"; //$NON-NLS-1$
private static final String ATTR_CLASS = "class"; //$NON-NLS-1$
private final IProcessFactory fProcessFactory;
private final Map fRemoteEnv = new HashMap();
private Process localProcess;
private PTY pty;
public LocalProcessBuilder(IRemoteConnection connection, List command) {
super(connection, command);
fRemoteEnv.putAll(System.getenv());
fProcessFactory = getProcessFactory();
}
public LocalProcessBuilder(IRemoteConnection connection, String... command) {
this(connection, Arrays.asList(command));
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.AbstractRemoteProcessBuilder#directory()
*/
@Override
public IFileStore directory() {
IFileStore dir = super.directory();
if (dir == null) {
String userDir = System.getProperty("user.dir"); //$NON-NLS-1$
if (userDir != null) {
dir = EFS.getLocalFileSystem().getStore(Path.fromOSString(userDir));
directory(dir);
}
}
return dir;
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.remote.core.AbstractRemoteProcessBuilder#environment()
*/
@Override
public Map environment() {
return fRemoteEnv;
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.remote.core.AbstractRemoteProcessBuilder#getSupportedFlags
* ()
*/
@Override
public int getSupportedFlags() {
return NONE;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteProcessBuilder#start(int)
*/
@Override
public IRemoteProcess start(int flags) throws IOException {
String commandArray[] = command().toArray(new String[0]);
if ((flags & IRemoteProcessBuilder.ALLOCATE_PTY) != 0) {
environment().put("TERM", "vt100"); //$NON-NLS-1$ //$NON-NLS-2$
}
String environmentArray[] = new String[environment().size()];
int index = 0;
for (Entry entry : environment().entrySet()) {
environmentArray[index++] = entry.getKey() + "=" + entry.getValue(); //$NON-NLS-1$
}
try {
if ((flags & IRemoteProcessBuilder.ALLOCATE_PTY) != 0) {
pty = new PTY(Mode.TERMINAL);
File dir = directory() != null ? directory().toLocalFile(EFS.NONE, new NullProgressMonitor()) : null;
localProcess = ProcessFactory.getFactory().exec(commandArray, environmentArray, dir, pty);
} else {
if (directory() != null) {
localProcess = fProcessFactory.exec(commandArray, environmentArray,
directory().toLocalFile(EFS.NONE, new NullProgressMonitor()));
} else {
localProcess = fProcessFactory.exec(commandArray, environmentArray);
}
}
} catch (CoreException e) {
throw new IOException(e.getMessage());
}
return new RemoteProcess(getRemoteConnection(), this);
}
public Process getProcess() {
return localProcess;
}
public PTY getPty() {
return pty;
}
private IProcessFactory getProcessFactory() {
IExtensionRegistry registry = Platform.getExtensionRegistry();
IExtensionPoint extensionPoint = registry.getExtensionPoint(RemoteCorePlugin.getUniqueIdentifier(), EXTENSION_POINT_ID);
IProcessFactory processFactory = null;
for (IExtension ext : extensionPoint.getExtensions()) {
final IConfigurationElement[] elements = ext.getConfigurationElements();
for (IConfigurationElement ce : elements) {
try {
processFactory = (IProcessFactory) ce.createExecutableExtension(ATTR_CLASS);
} catch (CoreException e) {
// Use default factory
}
}
}
if (processFactory == null) {
processFactory = new IProcessFactory() {
@Override
public Process exec(String cmd) throws IOException {
return Runtime.getRuntime().exec(cmd);
}
@Override
public Process exec(String[] cmdarray) throws IOException {
return Runtime.getRuntime().exec(cmdarray);
}
@Override
public Process exec(String[] cmdarray, String[] envp) throws IOException {
return Runtime.getRuntime().exec(cmdarray, envp);
}
@Override
public Process exec(String cmd, String[] envp) throws IOException {
return Runtime.getRuntime().exec(cmd, envp);
}
@Override
public Process exec(String cmd, String[] envp, File dir) throws IOException {
return Runtime.getRuntime().exec(cmd, envp, dir);
}
@Override
public Process exec(String[] cmdarray, String[] envp, File dir) throws IOException {
return Runtime.getRuntime().exec(cmdarray, envp, dir);
}
};
}
return processFactory;
}
}
LocalProcessService.java 0000664 0000000 0000000 00000003732 12721140017 0042245 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core/services/local package org.eclipse.remote.internal.core.services.local;
import java.util.List;
import java.util.Map;
import org.eclipse.core.runtime.Path;
import org.eclipse.remote.core.IRemoteConnection;
import org.eclipse.remote.core.IRemoteConnection.Service;
import org.eclipse.remote.core.IRemoteProcessBuilder;
import org.eclipse.remote.core.IRemoteProcessService;
public class LocalProcessService implements IRemoteProcessService {
private final IRemoteConnection remoteConnection;
private String workingDirectory;
public LocalProcessService(IRemoteConnection remoteConnection) {
this.remoteConnection = remoteConnection;
}
public static class Factory implements IRemoteProcessService.Factory {
@SuppressWarnings("unchecked")
@Override
public T getService(IRemoteConnection remoteConnection, Class service) {
if (IRemoteProcessService.class.equals(service)) {
return (T) new LocalProcessService(remoteConnection);
}
return null;
}
}
@Override
public IRemoteConnection getRemoteConnection() {
return remoteConnection;
}
@Override
public Map getEnv() {
return System.getenv();
}
@Override
public String getEnv(String name) {
return System.getenv(name);
}
@Override
public IRemoteProcessBuilder getProcessBuilder(List command) {
return new LocalProcessBuilder(remoteConnection, command);
}
@Override
public IRemoteProcessBuilder getProcessBuilder(String... command) {
return new LocalProcessBuilder(remoteConnection, command);
}
@Override
public String getWorkingDirectory() {
if (workingDirectory == null) {
workingDirectory = System.getProperty("user.home"); //$NON-NLS-1$
if (workingDirectory == null) {
workingDirectory = System.getProperty("user.dir"); //$NON-NLS-1$
if (workingDirectory == null) {
workingDirectory = Path.ROOT.toOSString();
}
}
}
return workingDirectory;
}
@Override
public void setWorkingDirectory(String path) {
workingDirectory = path;
}
}
LocalResource.java 0000664 0000000 0000000 00000003447 12721140017 0041100 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core/services/local /*******************************************************************************
* Copyright (c) 2011 IBM 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:
* IBM - Initial API and implementation
*******************************************************************************/
package org.eclipse.remote.internal.core.services.local;
import java.net.URI;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IProgressMonitor;
import org.eclipse.remote.core.IRemoteResource;
public class LocalResource implements IRemoteResource {
private IResource fResource;
public LocalResource(IResource resource) {
fResource = resource;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteResource#getDefaultLocationURI(org.eclipse.core.resources.IResource)
*/
@Override
public URI getActiveLocationURI() {
return fResource.getLocationURI();
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteResource#getResource()
*/
@Override
public IResource getResource() {
return fResource;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteResource#refresh(org.eclipse.core.runtime.IProgressMonitor)
*/
@Override
public void refresh(IProgressMonitor monitor) throws CoreException {
fResource.refreshLocal(IResource.DEPTH_INFINITE, monitor);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteResource#setResource(org.eclipse.core.resources.IResource)
*/
@Override
public void setResource(IResource resource) {
fResource = resource;
}
}
Messages.java 0000664 0000000 0000000 00000000700 12721140017 0040072 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core/services/local package org.eclipse.remote.internal.core.services.local;
import org.eclipse.osgi.util.NLS;
public class Messages extends NLS {
private static final String BUNDLE_NAME = "org.eclipse.remote.internal.core.services.local.messages"; //$NON-NLS-1$
public static String LocalConnectionProviderService_LocalConnectionName;
static {
// initialize resource bundle
NLS.initializeMessages(BUNDLE_NAME, Messages.class);
}
private Messages() {
}
}
messages.properties 0000664 0000000 0000000 00000000071 12721140017 0041406 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.core/src/org/eclipse/remote/internal/core/services/local LocalConnectionProviderService_LocalConnectionName=Local
org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.doc.isv/ 0000775 0000000 0000000 00000000000 12721140017 0024201 5 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.doc.isv/.project 0000664 0000000 0000000 00000000755 12721140017 0025657 0 ustar 00root root 0000000 0000000
org.eclipse.remote.doc.isvorg.eclipse.pde.ManifestBuilderorg.eclipse.pde.SchemaBuilderorg.eclipse.pde.PluginNature
org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.doc.isv/META-INF/ 0000775 0000000 0000000 00000000000 12721140017 0025341 5 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.doc.isv/META-INF/MANIFEST.MF 0000664 0000000 0000000 00000001002 12721140017 0026764 0 ustar 00root root 0000000 0000000 Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: Eclipse Remote Development documentation plug-in
Bundle-SymbolicName: org.eclipse.remote.doc.isv;singleton:=true
Bundle-Version: 1.0.0.qualifier
Bundle-Vendor: Eclipse PTP
Require-Bundle: org.eclipse.remote.console,
org.eclipse.remote.core,
org.eclipse.remote.jsch.core,
org.eclipse.remote.jsch.ui,
org.eclipse.remote.serial.core,
org.eclipse.remote.serial.ui,
org.eclipse.remote.telnet.core,
org.eclipse.remote.telnet.ui,
org.eclipse.remote.ui
org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.doc.isv/about.html 0000664 0000000 0000000 00000002447 12721140017 0026210 0 ustar 00root root 0000000 0000000
About
About This Content
May 2, 2006
License
The Eclipse Foundation makes available all content in this plug-in ("Content"). Unless otherwise indicated below, the Content is provided to you under the terms and conditions of the
Eclipse Public License Version 1.0 ("EPL"). A copy of the EPL is available at http://www.eclipse.org/legal/epl-v10.html.
For purposes of the EPL, "Program" will mean the Content.
If you did not receive this Content directly from the Eclipse Foundation, the Content is being redistributed by another party ("Redistributor") and different terms and conditions may
apply to your use of any object code in the Content. Check the Redistributor's license that was provided with the Content. If no such license exists, contact the Redistributor. Unless otherwise
indicated below, the terms and conditions of the EPL still apply to any source code in the Content and such source code may be obtained at http://www.eclipse.org.
This section describes the main concepts and services implemented by the Eclipse remote framework.
Concepts
Some few concepts are needed to understand the framework's services overall. They are described in the next sections.
Connection type
An connection type (IRemoteConnectionType) abstracts a remote protocol to host access. As of version 2.0.1, the framework provides the ssh (implemented through JSch framework), Telnet and Local types.
The connection type is obtained from the remote services manager either by passing its scheme ID (Identification) or an URI.
It has the newConnection method where a new connection of this type is created. It also holds the list of all connections already created that belongs to it.
Remote connection
The remote connection (IRemoteConnection) interface is used to manage a connection to a single remote host. A connection must be established (open) before any other operations are permitted. All operations carried out on remote host should be evoked from its associated services, which are get with getService method.
Connections are read-only objects. In order to change the attributes of a connection, a working copy (IRemoteConnectionWorkingCopy) must be created. The host attributes getters and setters can also be managed with connection host service (IRemoteConnectionHostService).
Every remote connection belongs to a connection type.
Remote resource
The remote resource interface (IRemoteResource) provides an adapter to a remote resource.
As of version 2.0.1, there are two types of remote resources: fully remote and synchronized. This interface provides a common mechanism for accessing resource information from either types.
Process builder
The process builder (IRemoteProcessBuilder) provides process operations on the remote host. This interface is intended to be a drop-in replacement for the Java SE ProcessBuilder class. See the java.lang.ProcessBuilder documentation for a description of the methods.
It is obtained from the process service (see IRemoteProcessService below) associated with a connection object that holds access information to the remote host.
Remote process
The remote process (IRemoteProcess) represents a process running on the remote host. Use it to manage the process (destroy), get exit status, and input/output/error streams.
Remote process are created using the IRemoteProcessBuilder interface.
Services
The remote services are implemented as OSGi services. There are available non-UI (core) and UI services.
Any given service can be associated with objects of the model (concepts) or nested to another one. In either case, an service instance is obtained by calling the getService method of its object's provider.
The main remote services are detailed in the next sections.
Services manager
The services manager (IRemoteServicesManager) interface provides the main entry point for accessing remote services. It can be obtained by calling RemoteServicesUtils.getService(IRemoteServicesManager.class) or using the Plugin's bundle context to access a OSGi service.
It provides access to connection types implemented by the framework and any connection already created.
File Service
The file service (IRemoteFileService) provides remote file manipulation operations on a given connection. It is obtained from a remote connection object by calling its getService(IRemoteFileService.class) method.
Using this interface, a path can be translated into an IFileStore object, and then manipulated using any of the normal EFS operations.
Its UI counterpart service (IRemoteUIFileService) comes with dialog widgets to browse files and directories on remote filesystem.
Process Service
The process service (IRemoteProcessService) provides services for starting up processes on a remote host. It is obtained from a remote connection object by calling its getService(IRemoteProcessService.class) method.
It is the entry point to get an IRemoteProcessBuilder object, used to spawn processes on the remote host. Environment variables of remote host are accessed using this service too.
Connection Service
The UI Connection service (IRemoteUIConnectionService) is used for manipulating connections in the UI, such as adding, editing, and opening connections.
Non-UI connection manipulation should use the IRemoteConnectionType interface (obtained from services manager) and the services related with IRemoteConnection interface.
The purpose of remote services API is to provide a programming interface to remote services that is agnostic to the actual remote services implementation. Currently the only implementation supported of SSH protocol uses JSch(Java Secure Channel) project (www.jcraft.com/jsch). An implementation for the local system (where Eclipse is run) and Telnet protocol are also provided.
The API is generic enough so that it is possible to use it for all remote or local operations. This is useful for situations where both a remote and local mode should be provided, but the programmer wants to avoid two separate code paths.
Types of services
The API is divided into two types of remote services: UI and non-UI.
UI services are for activities such as file browsing that require use of the UI. In particular, it provides a main preference page (under "Remote Development > Remote Connections") which allow connections to be created, edited, removed, opened, and closed.
Non-UI services are purely programmatic, they provides a set of core services for manipulating remote resources. The non-UI services can be used independently of the UI services.
Remote Services Plugins
The remote services are divided into two plugins. These plugins should have no dependencies other than the platform.
Remote service implementations provide the actual remote functionality using a particular remote protocol. These are supplied as a set of adapter plugins.
As of version 2.0.1, there is currently one implementation of SSH protocol using JSch:
org.eclipse.remote.jsch.core
org.eclipse.remote.jsch.ui
The Telnet protocol implementation and UI widgets are provided by the plugins:
org.eclipse.remote.telnet.core
org.eclipse.remote.telnet.ui
These plugins are dependent on the remote services implementations, but are optional for the remote services API. The API will automatically detect the installed plugins.
Once with services manager object, you obtain a connection type by its scheme ID or any URI to the remote host, as in:
IRemoteConnectionType connType;
// Get connection type by Scheme ID
connType = servicesManager.getConnectionType("ssh");
// Get connection type by URI
URI uri = URI.create("ssh://MyConnection/path/to/file");
connType = servicesManager.getConnectionType(uri);
The Telnet connection type can not be obtained by URI, instead you must use its ID:
The remote connection is obtained from connection type object by either name or an URI. For example:
IRemoteConnection connection;
// Get connection by URI
URI uri = URI.create("ssh://MyConnection/path/to/file");
connection = connType.getConnection(uri);
// Get connection by name
connection = connType.getConnection("MyConnection");
If the connection does not exist, it can be created with a connection type (IRemoteConnectionType) instance. Use the connection type object to delete it as well:
IRemoteConnectionWorkingCopy rcwc; // Writable connection working copy
rcwc = connType.newConnection(connectionName); // Create connection of connection type
IRemoteConnectionHostService hostServices; // Fill connection information through host service
hostServices = rcwc.getService(IRemoteConnectionHostService.class); // Obtain the service from working copy instance
hostServices.setHostname(address);
hostServices.setUsername(username);
hostServices.setUsePassword(true);
hostServices.setPassword(passwd);
IRemoteConnection connection = rcwc.save(); // Finally save the working copy, then get the connection (read-only) object
connType.removeConnection(connection); // Remove connection and all resources associated with it
Connections can be opened or closed programmatically. Some operations requires the connection opened:
connection.open(monitor); // Open the connection but allow the user to cancel the progress monitor
connection.close(); // Now close it
The file service is obtained from a connection object. Remote resources can be manipulated with IFileStore:
IRemoteFileService fileService = connection.getService(IRemoteFileService.class);
// The remote connection does not need to be open to get the resource
IFileStore fs = fileService.getResource("/path/to/resource");
// But the remote connection need to be open to operate on the resource
if (fs.fetchInfo().exists()) {
System.out.println("It exists!");
}
In the other hand, the UI file service is obtained from a connection type rather than the connection. The reason is that it allows user to select the connection in a list. It is also possible to set the connection:
IRemoteUIFileService uiFileService = conn.getConnectionType().getService(IRemoteUIFileService.class);
uiFileService.setConnection(connection); // Set default connection (optional)
uiFileService.showConnections(true); // Also show list of available connections
// The return value is the path of the directory selected on the remote system
String path = uiFileService.browseDirectory(shell, "Browse /home", "/home", IRemoteUIConstants.NONE);
Use a connection object to get its associated process service (IRemoteProcessService). Then obtain a process builder (IRemoteProcessBuilder), so that commands can be executed on remote host:
IRemoteProcessService ps = connection.getService(IRemoteProcessService.class);
IRemoteProcessBuilder pb = ps.getProcessBuilder("/bin/ls", "-l");
IRemoteProcess process = pb.start();
// Use IRemoteProcess to manage the process. Alternatively, use an adaptor to java.lang.Process
Process process2 = new RemoteProcessAdapter(process);
Use the IRemoteResource adapter to get a location URI of the project (IProject):
IRemoteResource resource = (IRemoteResource)project.getAdapter(IRemoteResource.class);
URI projectLocation = resource.getActiveLocationURI(); // Get URI to active location
The Eclipse Foundation makes available all content in this plug-in ("Content"). Unless otherwise indicated below, the Content is provided to you under the terms and conditions of the
Eclipse Public License Version 1.0 ("EPL"). A copy of the EPL is available at http://www.eclipse.org/legal/epl-v10.html.
For purposes of the EPL, "Program" will mean the Content.
If you did not receive this Content directly from the Eclipse Foundation, the Content is being redistributed by another party ("Redistributor") and different terms and conditions may
apply to your use of any object code in the Content. Check the Redistributor's license that was provided with the Content. If no such license exists, contact the Redistributor. Unless otherwise
indicated below, the terms and conditions of the EPL still apply to any source code in the Content and such source code may be obtained at http://www.eclipse.org.
org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.jsch.core/build.properties 0000664 0000000 0000000 00000000246 12721140017 0027731 0 ustar 00root root 0000000 0000000 source.. = src/
output.. = bin/
bin.includes = META-INF/,\
.,\
plugin.xml,\
plugin.properties,\
about.html org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.jsch.core/plugin.properties 0000664 0000000 0000000 00000000765 12721140017 0030136 0 ustar 00root root 0000000 0000000 ###############################################################################
# Copyright (c) 2013 IBM 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
#
###############################################################################
pluginName=JSch Remote Support
pluginProvider=Eclipse PTP
org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.jsch.core/plugin.xml 0000664 0000000 0000000 00000007266 12721140017 0026545 0 ustar 00root root 0000000 0000000
org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.jsch.core/pom.xml 0000664 0000000 0000000 00000001215 12721140017 0026026 0 ustar 00root root 0000000 0000000
4.0.0org.eclipse.remoteremote-parent2.1.0-SNAPSHOT../../releng/org.eclipse.remote.build/pom.xmlorg.eclipse.remote.jsch.coreeclipse-plugin1.0.0-SNAPSHOT
org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.jsch.core/src/ 0000775 0000000 0000000 00000000000 12721140017 0025301 5 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.jsch.core/src/org/ 0000775 0000000 0000000 00000000000 12721140017 0026070 5 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.jsch.core/src/org/eclipse/ 0000775 0000000 0000000 00000000000 12721140017 0027514 5 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.jsch.core/src/org/eclipse/remote/ 0000775 0000000 0000000 00000000000 12721140017 0031007 5 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.jsch.core/src/org/eclipse/remote/internal/ 0000775 0000000 0000000 00000000000 12721140017 0032623 5 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.jsch.core/src/org/eclipse/remote/internal/jsch/0000775 0000000 0000000 00000000000 12721140017 0033552 5 ustar 00root root 0000000 0000000 core/ 0000775 0000000 0000000 00000000000 12721140017 0034423 5 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.jsch.core/src/org/eclipse/remote/internal/jsch Activator.java 0000664 0000000 0000000 00000005460 12721140017 0037227 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.jsch.core/src/org/eclipse/remote/internal/jsch/core package org.eclipse.remote.internal.jsch.core;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Plugin;
import org.eclipse.core.runtime.Status;
import org.eclipse.jsch.core.IJSchService;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceReference;
/**
* The activator class controls the plug-in life cycle
*/
public class Activator extends Plugin {
// The plug-in ID
public static final String PLUGIN_ID = "org.eclipse.remote.jsch.core"; //$NON-NLS-1$
// The shared instance
private static Activator plugin;
/**
* Returns the shared instance
*
* @return the shared instance
*/
public static Activator getDefault() {
return plugin;
}
/**
* Get unique identifier
*
* @return
* @since 5.0
*/
public static String getUniqueIdentifier() {
if (getDefault() == null) {
return PLUGIN_ID;
}
return getDefault().getBundle().getSymbolicName();
}
/**
* Logs the specified status with this plug-in's log.
*
* @param status
* status to log
*/
public static void log(IStatus status) {
getDefault().getLog().log(status);
}
/**
* Logs an internal error with the specified message.
*
* @param message
* the error message to log
*/
public static void log(String message) {
log(new Status(IStatus.ERROR, getUniqueIdentifier(), IStatus.ERROR, message, null));
}
/**
* Logs an internal error with the specified throwable
*
* @param e
* the exception to be logged
*/
public static void log(Throwable e) {
log(new Status(IStatus.ERROR, getUniqueIdentifier(), IStatus.ERROR, e.getMessage(), e));
}
private IJSchService fJSchService;
/**
* The constructor
*/
public Activator() {
}
/**
* Return the OSGi service with the given service interface.
*
* @param service service interface
* @return the specified service or null if it's not registered
*/
public static T getService(Class service) {
BundleContext context = plugin.getBundle().getBundleContext();
ServiceReference ref = context.getServiceReference(service);
return ref != null ? context.getService(ref) : null;
}
public IJSchService getService() {
return fJSchService;
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.ui.plugin.AbstractUIPlugin#start(org.osgi.framework.BundleContext
* )
*/
@Override
public void start(BundleContext context) throws Exception {
super.start(context);
plugin = this;
ServiceReference reference = context.getServiceReference(IJSchService.class);
fJSchService = context.getService(reference);
}
/*
* (non-Javadoc)
*
* @see
* org.eclipse.ui.plugin.AbstractUIPlugin#stop(org.osgi.framework.BundleContext
* )
*/
@Override
public void stop(BundleContext context) throws Exception {
plugin = null;
super.stop(context);
}
}
ArgumentParser.java 0000664 0000000 0000000 00000023005 12721140017 0040225 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.jsch.core/src/org/eclipse/remote/internal/jsch/core /*******************************************************************************
* Copyright (c) 2007 IBM Corporation 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
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.remote.internal.jsch.core;
import java.text.CharacterIterator;
import java.text.StringCharacterIterator;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
/**
* Utilitiy class for managing command line arguments.
*
*/
public class ArgumentParser {
private static List parseCommandline(String commandline) {
ArrayList result = new ArrayList();
StringCharacterIterator iterator = new StringCharacterIterator(commandline);
for (iterator.first(); iterator.current() != CharacterIterator.DONE; iterator.next()) {
// Restart to skip white space
if (Character.isWhitespace(iterator.current())) {
continue;
}
// Read token
StringBuffer buffer = new StringBuffer();
token_reader: for (; iterator.current() != CharacterIterator.DONE; iterator.next()) {
char tokenChar = iterator.current();
// A white space terminates the token
if (Character.isWhitespace(tokenChar)) {
break token_reader;
}
// Handle character that composes the token
switch (tokenChar) {
case '"': {
/*
* Read all text within double quotes or until end of
* string. Allows escaping.
*/
iterator.next(); // Skip quote
quoted_reader: while ((iterator.current() != CharacterIterator.DONE) && (iterator.current() != '"')) {
char innerChar = iterator.current();
switch (innerChar) {
case '\\':
char nextChar = iterator.next();
switch (nextChar) {
case CharacterIterator.DONE:
break quoted_reader;
case '"':
// Add the character, but remove the escape
buffer.append(nextChar);
iterator.next();
continue quoted_reader;
default:
// Add the character and keep escape
buffer.append(innerChar);
buffer.append(nextChar);
iterator.next();
continue quoted_reader;
}
default:
buffer.append(innerChar);
iterator.next();
continue quoted_reader;
}
}
continue token_reader;
}
case '\'': {
/*
* Read all text within single quotes or until end of
* string. No escaping.
*/
iterator.next(); // Skip the quote
while ((iterator.current() != CharacterIterator.DONE) && (iterator.current() != '\'')) {
buffer.append(iterator.current());
iterator.next();
}
continue token_reader;
}
case '\\': {
/*
* Read escaped char.
*/
char nextChar = iterator.next();
switch (nextChar) {
case CharacterIterator.DONE:
break token_reader;
case '\n':
// Ignore newline. Both lines are concatenated.
continue token_reader;
default:
// Add the character, but remove the escape
buffer.append(nextChar);
continue token_reader;
}
}
default:
/*
* Any other char, add to the buffer.
*/
buffer.append(tokenChar);
continue token_reader;
}
}
result.add(buffer.toString());
}
return result;
}
private final List tokens;
/**
* Create a command line representation from an array of strings. The first
* element of the list is assumed to be the command, the remaining, the
* arguments. The elements are not parsed not (un)escaped., but taked as the
* are.
*
*/
public ArgumentParser(List tokenList) {
this.tokens = new ArrayList(tokenList);
}
/**
* Create a command line representation from the string with a shell command
* line. The command line is parsed and split on spaces. Quoted or escaped
* spaces are preserved..
*
*/
public ArgumentParser(String commandline) {
this.tokens = parseCommandline(commandline);
}
/**
* Create a command line representation from an array of strings. The first
* element of the array is assumed to be the command, the remaining, the
* arguments. The elements are not parsed not (un)escaped., but taked as the
* are.
*
*/
public ArgumentParser(String tokenArray[]) {
this(Arrays.asList(tokenArray));
}
/**
* Create a command line representation from the command and an list of
* parameters. The elements are not parsed not (un)escaped., but taked as
* the are.
*
*/
public ArgumentParser(String command, List parameterList) {
this.tokens = new ArrayList();
this.tokens.add(command);
this.tokens.addAll(parameterList);
}
/**
* Create a command line representation from the command and an array of
* parameters. The elements are not parsed not (un)escaped., but taked as
* the are.
*
*/
public ArgumentParser(String command, String parameterArray[]) {
this(command, Arrays.asList(parameterArray));
}
private StringBuffer escapeToken(String token, boolean fullEscape) {
StringBuffer buffer = new StringBuffer();
StringCharacterIterator iter = new StringCharacterIterator(token);
for (char c = iter.first(); c != CharacterIterator.DONE; c = iter.next()) {
if (Character.isWhitespace(c)) {
buffer.append('\\');
buffer.append(c);
continue;
}
switch (c) {
case '(':
case ')':
case '[':
case ']':
case '{':
case '}':
case '|':
case '\\':
case '*':
case '&':
case '^':
case '%':
case '$':
case '#':
case '@':
case '!':
case '~':
case '`':
case '\'':
case '"':
case ':':
case ';':
case '?':
case '>':
case '<':
case '\n':
if (fullEscape) {
buffer.append('\\');
}
buffer.append(c);
continue;
case ' ':
buffer.append('\\');
buffer.append(c);
continue;
default:
buffer.append(c);
continue;
}
}
return buffer;
}
/**
* Returns the command of the command line, assuming that the first entry is
* always the command.
*
* @return The command or null if the command lines has no command nor
* arguments.
*/
public String getCommand() {
if (this.tokens.size() == 0) {
return null;
}
return this.tokens.get(0);
}
/**
* Convert all tokens in a full command line that can be executed in a
* shell.
*
* @param fullEscape
* If every special character shall be escaped. If false, only
* white spaces are escaped and the shell will interpret the
* special chars. If true, then all special chars are quoted.
*/
public String getCommandLine(boolean fullEscape) {
StringBuffer buffer = new StringBuffer();
Iterator iterator = this.tokens.iterator();
boolean first = true;
while (iterator.hasNext()) {
String token = iterator.next();
if (!first) {
buffer.append(' ');
} else {
first = false;
}
buffer.append(escapeToken(token, fullEscape));
}
return buffer.toString();
}
/**
* Returns the command of the command line, assuming that the first entry is
* always the command.
*
* @return The command or null if the command lines has no command nor
* arguments.
* @param fullEscape
* If every special character shall be escaped. If false, only
* white spaces are escaped and the shell will interpret the
* special chars. If true, then all special chars are quoted.
*/
public String getEscapedCommand(boolean fullEscalpe) {
if (this.tokens.size() == 0) {
return null;
}
return escapeToken(this.tokens.get(0), fullEscalpe).toString();
}
/**
* Returns a list of all arguments, assuming that the first entry is the
* command name.
*
* @return The Array or null if the command lines has no command nor
* arguments.
*/
public String[] getParameterArray() {
if (this.tokens.size() == 0) {
return null;
}
return this.tokens.subList(1, this.tokens.size()).toArray(new String[this.tokens.size() - 1]);
}
/**
* Returns a list of all arguments, assuming that the first entry is the
* command name.
*
* @return The List or null if the command lines has no command nor
* arguments.
*/
public List getParameterList() {
if (this.tokens.size() == 0) {
return null;
}
return new ArrayList(this.tokens.subList(1, this.tokens.size()));
}
/**
* Returns the total number of entries.
*
* @return
*/
public int getSize() {
return this.tokens.size();
}
/**
* Returns a List of all entries of the command line.
*
* @return The Array
*/
public String[] getTokenArray() {
return this.tokens.toArray(new String[this.tokens.size()]);
}
/**
* Returns a List of all entries of the command line.
*
* @return The List
*/
public List getTokenList() {
return new ArrayList(this.tokens);
}
/**
* Returns a representation of the command line for debug purposes.
*/
@Override
public String toString() {
StringBuffer buffer = new StringBuffer();
buffer.append("<"); //$NON-NLS-1$
Iterator iterator = this.tokens.iterator();
boolean first = true;
while (iterator.hasNext()) {
String token = iterator.next();
if (!first) {
buffer.append('\n');
} else {
first = false;
}
buffer.append(token);
}
buffer.append(">"); //$NON-NLS-1$
return buffer.toString();
}
}
JSchCommandShellService.java 0000664 0000000 0000000 00000003430 12721140017 0041725 0 ustar 00root root 0000000 0000000 org.eclipse.remote-R2_1_0/bundles/org.eclipse.remote.jsch.core/src/org/eclipse/remote/internal/jsch/core /*******************************************************************************
* Copyright (c) 2015 QNX Software Systems 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
*
* Contributors:
* QNX Software Systems - Initial API and implementation
*******************************************************************************/
package org.eclipse.remote.internal.jsch.core;
import java.io.IOException;
import org.eclipse.remote.core.IRemoteCommandShellService;
import org.eclipse.remote.core.IRemoteConnection;
import org.eclipse.remote.core.IRemoteProcess;
public class JSchCommandShellService implements IRemoteCommandShellService {
private IRemoteConnection fRemoteConnection;
public JSchCommandShellService(IRemoteConnection remoteConnection) {
fRemoteConnection = remoteConnection;
}
@Override
public IRemoteConnection getRemoteConnection() {
return fRemoteConnection;
}
@Override
public IRemoteProcess getCommandShell(int flags) throws IOException {
return new JSchProcessBuilder(getRemoteConnection()).start(flags);
}
public static class Factory implements IRemoteConnection.Service.Factory {
/*
* (non-Javadoc)
*
* @see org.eclipse.remote.core.IRemoteConnection.Service.Factory#getService(org.eclipse.remote.core.IRemoteConnection,
* java.lang.Class)
*/
@Override
@SuppressWarnings("unchecked")
public