+ Native Execution API is intended to provide a flexible and extendable + aid for running external processes on a local or remote hosts. +
++ The module itself doesn't provide any specific implementation. It + also doesn't make any strict obligations on what is considered to be a + Process or a Host. But it has some assumptions regarging those + entities though... +
++ But first, two words about what this module is about and what it is not. + This module is NOT about hosts management nor it is about connections + management system (in sense of UI elements, persistance, etc.). This + module is almost entirely about establishing a connection to some + destination target (usually a host), running a process there and + getting back it's I/O. Also some basic utilities are provided that + could make these tasks easier to achieve. +
++ From the SPI implementor point of view this module is a set of + extension points to introduce own notion of Process/Connection + and add own implementation without a need to deal (a lot) with + threading and other annoying issues... +
++ This API/SPI was written while keeping in mind a previous experiense + with NativeExecution module. An attempt to re-design some questinoable + approaches used in the previous implementation has been made. +
+ Requirements for the module: ++ The entity a user of this API starts with is a Connection. + Any connection is identified by an URI. ConnectionManager is asked + to give a connection for some URI and this Connection becames a + provider of a NativeProcessBuilder which in turn can be used to + start a NativeProcess in the context of that Connection. +
++ A scheme of an URI passed to the ConnectionManager is used to lookup + an SPI implementor that can initiate, establish and provide a connection. + All SPI implementors that deal with particular 'kind' of connections + are registered in "ConnectionService/<scheme>" lookup path. +
+
+ There are already many users on an old API. The intention (and
+ success metric) is to move all client of the old API to this one.
+
+ Unit tests will be provided. Also there should be no regression in
+ old API client's functionality.
+
+ This module should became a public replacement for dlight.nativeexecution module.
+
+ As API is changed all friend-modules should be modified to use this new one.
+ In most cases this should not be difficult, but taking into accont the
+ number of 'old' API clients (100+ friend modules) this task could take a while.
+ Estimation is two months.
+
+ This module could be used for running external processes on a local and
+ remote hosts. It is extendable and SPI implementors could provide different
+ implementation of connections and processes... But at least two
+ implementations are to be provided together with this module (in a
+ separate implementation module).
+
+ They are for starting local processes ("localhost" scheme) and remote
+ processes using Jsch services ("ssh" scheme).
+
+ Common usage is:
+
+ try {
+ URI uri = new URI("ssh://tester:tester@testmachine.com");
+ Connection connection = ConnectionManager.connect(uri);
+
+ NativeProcessBuilder npb = connection.newProcessBuilder();
+ npb.setWorkingDirectory("/tmp/test").setCommand("my-command");
+ npb.getEnvironmentMap().prependPath("PATH", "/path/to/my-command");
+
+ ProcessUtils.ExitStatus result = ProcessUtils.execute(npb);
+ if (result.isOK()) {
+ System.out.println(result.output);
+ }
+ } catch (NativeExecutionException ex) {
+ Exceptions.printStackTrace(ex);
+ } catch (URISyntaxException ex) {
+ Exceptions.printStackTrace(ex);
+ }
+
+
+ This module provides an API/SPI be used for running external + processes on a local or remote hosts. +
++ Process-related API from dlight.nativeexecution is planned to be + first deprecated and then, when transition is done, demoved from + the product. +
++ Yes. Currently it has no UI except a ProgressBar which indicates a + connection to a remote host progress. +
++ N/A +
+
+ There is no any persistance in this module (at least for now).
+
+ Module is extendable with SPI provided.
+
+ jre 1.6+ +
++ JRE is enough. +
++ none. The default implementation of remote processes support uses jsch. + But this is a different (implementation) module. +
+
+ This module is almos a pure API/SPI so it is platform-independent.
+
+ Implementation module with support of Windows, Linux, Solaris and MacOS
+ will be provided.
+
+ This module needs implementation of the "localhost" scheme support.
+ OpenIDE-Module-Needs: ConnectionService.localhost
+
+ just JAR. +
++ Yes. +
++ There are several public API/SPI packages provided by this module. +
++ Installation location doesn't not matter, but as this module will + become a part of the ide cluster, most likely it will be in a shared + location. +
++ No. +
++ No. +
++ See ConnectionInfoProvider javadoc. +
++ There are connection-specific properties that could be of any kind. + SPI implementor defines pairs of property name -- class and later + API clients are expected to get/set defined properties of defined + classes. Runtime type checking is performed in put/get methods. See + javadoc for NativeProcessBuilder, AuthDataProvider. +
++ No. +
++ Yes. This module is about starting external processes. It is up to + client to work with a result of execution. +
++ "ide.execution.logger.level" is used to define a logger level. +
++ No. +
++ Some classes (most) are thread-safe, others are not. If class is not + thread-safe, it is described in a javadoc. +
++ N/A +
++ N/A +
++ N/A +
++ Yes, Lookup is in use. Connection has an associated Lookup that is + explored to get implementations of some specific services + (like ConnectionInfoProvider, SignalSupportProvider). + Also AuthDataProvider, URIIdentifier and Connector implementations + are registered in the global lookup within a "ConnectionService/<scheme>" + path. +
++ No. +
++ No. +
++ No. +
++ No. +
++ No. +
++ N/A +
++ No. +
++ Yes. They are run outside the ETD. +
++ N/A +
+
+ There is a code that can be plugged in and that can influence the
+ performance (like listeners implementations, as they are notified
+ synchroniously). But this is done outside the EDT...
+
+ No. +
+
+ Yes. There is a thread that is started once a second to test if all
+ known connections are still alive.
+
+ This thread exists only if there are listeners that are waiting for
+ "connection lost" event and only if there is at least one active
+ connection.
+
+ No. +
++ No. +
++ No. +
++ No. +
++ No. +
++ No. +
++ No. +
+Connection provides an access to a {@link ProcessBuilder} in the context + * of the associated session. One should use services provided by the + * {@link ConnectionManager} class to get a Connection.
+ * + * @author akrasny + */ +public final class Connection implements org.netbeans.api.extexecution.ProcessBuilder.Provider { + + private final Object implLock = new Object(); + private ConnectionImplementation impl; + + /** + * Constructs a new API object for provided implementation. + * + * @param uri an URI this connection is associated with. + */ + private Connection(ConnectionImplementation impl) { + this.impl = impl; + } + + /** + * Returns an actual URI this connection is associated with. + * + * @return an URI this connection is associated with. + * @see ConnectorImplementation + * @see URIIdentifier + */ + public URI getURI() { + synchronized (implLock) { + return impl.getURI(); + } + } + + /** + * Tests if the connection is alive. + * + * @return true if connection is established, false otherwise. + */ + public boolean isConnected() { + synchronized (implLock) { + return impl == null ? false : impl.isConnected(); + } + } + + /** + * Creates a new {@link NativeProcessBuilder} to be used for starting + * processes within this connection. + * + * @return a new not configured {@link NativeProcessBuilder}. + * @throws NativeExecutionException if some problem occurred + */ + public NativeProcessBuilder newNativeProcessBuilder() throws NativeExecutionException { + synchronized (implLock) { + if (!isConnected()) { + throw new BrokenConnectionException(impl.getURI()); + } + + return NativeProcessBuilderFactory.getDefault().newProcessBuilder(impl.newProcessBuilderImpl(), this); + } + } + + /** + * Creates a new {@link org.netbeans.api.extexecution.ProcessBuilder} to be used for starting + * processes within this connection. + *
+ * The returned process builder is not thread safe.
+ *
+ * @return new {@link org.netbeans.api.extexecution.ProcessBuilder}.
+ * @throws ConnectException if the connection object is not actually connected
+ * @throws InterruptedIOException if the user interrupted or canceled the
+ * communication
+ * @throws NoRouteToHostException if there is problem with connection to host
+ * @throws IOException if some problem occurred
+ */
+ @Override
+ public org.netbeans.api.extexecution.ProcessBuilder getProcessBuilder()
+ throws ConnectException, InterruptedIOException, NoRouteToHostException, IOException {
+ synchronized (implLock) {
+ if (!isConnected()) {
+ throw new ConnectException(impl.getURI().toString());
+ }
+
+ return ProcessBuilderFactory.createProcessBuilder(
+ new NativeProcessFactory(NativeProcessBuilderFactory.getDefault().newProcessBuilder(impl.newProcessBuilderImpl(), this)),
+ getDisplayName());
+ }
+ }
+
+ /**
+ * Returns a human-readable string representation of the connection.
+ *
+ * @return a string representation of the connection.
+ */
+ @Override
+ public String toString() {
+ synchronized (implLock) {
+ return impl.toString();
+ }
+ }
+
+ public final boolean isLocal() {
+ return this.equals(ConnectionManager.getLocalConnection());
+ }
+
+ public String getDisplayName() {
+ return toString();
+ }
+
+ //
All ConnectionManager's methods are thread-safe.
+ * + * @author akrasny + */ +public final class ConnectionManager { + + private static final Connection LOCAL_CONNECTION; + + static { + Connection local = null; + try { + local = ConnectionManager.connect(new URI("localhost"), null); // NOI18N + } catch (Throwable th) { + Exceptions.printStackTrace(th); + } finally { + LOCAL_CONNECTION = local; + } + } + + private ConnectionManager() { + } + + /** + * Returns a connection to a local host. + * + *This connection is always active (connected) and doesn't require any + * authorization.
+ * + * @return the connection to a localhost (current host, current user). + */ + public static Connection getLocalConnection() { + return LOCAL_CONNECTION; + } + + /** + * + * Returns previously established {@link Connection} identified by the same + * or equivalent URI. + * + *This method is fast and could be invoked from the EDT.
+ * + *There is a notion of equivalent URIs that could verbally differ, but + * denote the same destination. See {@link URIIdentifier}.
+ * + * + * @param uri the URI that identifies a connection to get. + * @return previously established active connection or {@code null}, if no + * active connection exists. + * + * @see URIIdentifier + */ + public static Connection getConnection(final URI uri) { + Connection connection = ConnectionsPool.get(uri); + + if (connection == null || !connection.isConnected()) { + return null; + } + + return connection; + } + + /** + * An implicit request to establish a connection with a destination + * identified by the provided URI. + * + *This method acts like {@code connect(uri, null)}
+ * + * @param uri the URI of a desired connection destination. + * @see #connect(URI, AuthDataProvider) + * @throws NativeExecutionException if connection process was canceled or + * failed by any other reason. + */ + public static Connection connect(URI uri) throws IOException { + return connect(uri, null); + } + + /** + * An implicit request to establish a connection with the destination + * identified by the provided URI using provided additional source of + * authentication data. + * + *No new connection is established if a connection identified by this or + * equivalent URI already exists. The existent one is returned instead.
+ * + *Infrastructure asks passed {@link AuthDataProvider} to provide any + * authentication data needed for connection establishment. In case no + * requested info is provided by the passed provider, the default one + * (supplied by an SPI implementor) is queried. Each of these providers + * could initiate user interaction in order to get needed information.
+ * + *This method could be called from any thread (including ETD). In latter + * case a modal dialog with a progress bar is used to avoid UI + * deadlocks.
+ * + *Note that provider may return a connection with an URI that is + * absolutely different from the passed one. This could happen, for example, + * when request connection to an URI that doesn't precisely identifies the + * final destination - like {@code ssh://testhost}. In this case + * AuthDataProvider could be asked to provide a user name and the URI of a + * connection could be changed to {@code ssh://user@testhost}.
+ * + * @param uri the URI of a desired connection destination. + * @param authProvider provider of authentication data needed for connection + * establishment. + * + * @throws NativeExecutionException if connection process was canceled or + * failed by any other reason. + */ + public static Connection connect(URI uri, AuthDataProvider authProvider) throws IOException { + Connection connection = ConnectionsPool.get(uri); + + if (connection != null && connection.isConnected()) { + return connection; + } + + ConnectionAccessor access = ConnectionAccessor.getDefault(); + ConnectionImplementation impl = Connector.connect(uri, authProvider); + assert impl != null; + + if (connection == null) { + connection = access.createConnection(impl); + ConnectionsPool.add(connection); + } else { + access.setImpl(connection, impl); + } + + ConnectionStateChangeEvent ev = new ConnectionStateChangeEvent(connection.getURI(), State.CONNECTION_ESTABLISHED); + ConnectionListeners.notifyListeners(connection.getURI(), ev); + return connection; + } + + /** + * An implicit request to close previously established connection. + * + * @param c Connection to terminate + */ + static void disconnect(Connection c) { + if (!c.isConnected()) { + return; + } + + ConnectionListeners.stopTrackingTask(); + ConnectionAccessor access = ConnectionAccessor.getDefault(); + access.getImpl(c).disconnect(); + if (!c.isConnected()) { + ConnectionStateChangeEvent ev = new ConnectionStateChangeEvent(c.getURI(), State.CONNECTION_CLOSED); + ConnectionListeners.notifyListeners(c.getURI(), ev); + } + } + + /** + * Adds a listener to state changes of a connection to a given URI. + * + *It permits you to listen to a connection which is not established + * yet, or continue listening to it after it is disconnected, reconnected, + * etc. + *
+ *A listener can listen to any number of URIs. Note that listeners are + * always held weakly - if the listener is collected, it is quietly + * removed.
+ * + * @param listener ConnectionStateChangeListener to listen to changes in + * Connection state. + * @param uri URI of the Connection target (even not connected yet existing) + */ + public static void addConnectionStateChangeListener(ConnectionStateChangeListener listener, URI uri) { + ConnectionListeners.addConnectionStateChangeListener(listener, uri); + } + + /** + * Removes a listener to state changes of a given connection destination. + * + * @param listener ConnectionStateChangeListener to be removed + * @param uri URI of the Connection target + */ + public static void removeConnectionStateChangeListener(ConnectionStateChangeListener listener, URI uri) { + ConnectionListeners.removeConnectionStateChangeListener(listener, uri); + } + + @ServiceProvider(service=ConnectionProvider.class) + public static class NativeConnectionProvider implements ConnectionProvider { + + @Override + public ProcessBuilder.Provider getConnection(URI uri) throws IOException { + Connection connection = ConnectionManager.getConnection(uri); + if (connection == null) { + connection = ConnectionManager.connect(uri); + } + return connection; + } + + @Override + public URI getLocal() { + return ConnectionManager.getLocalConnection().getURI(); + } + + } +} diff --git a/cnd.execution/src/org/netbeans/modules/cnd/execution/api/ConnectionStateChangeEvent.java b/cnd.execution/src/org/netbeans/modules/cnd/execution/api/ConnectionStateChangeEvent.java new file mode 100644 --- /dev/null +++ b/cnd.execution/src/org/netbeans/modules/cnd/execution/api/ConnectionStateChangeEvent.java @@ -0,0 +1,113 @@ +/* + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. + * + * Copyright 2012 Oracle and/or its affiliates. All rights reserved. + * + * Oracle and Java are registered trademarks of Oracle and/or its affiliates. + * Other names may be trademarks of their respective owners. + * + * The contents of this file are subject to the terms of either the GNU + * General Public License Version 2 only ("GPL") or the Common + * Development and Distribution License("CDDL") (collectively, the + * "License"). You may not use this file except in compliance with the + * License. You can obtain a copy of the License at + * http://www.netbeans.org/cddl-gplv2.html + * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the + * specific language governing permissions and limitations under the + * License. When distributing the software, include this License Header + * Notice in each file and include the License file at + * nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the GPL Version 2 section of the License file that + * accompanied this code. If applicable, add the following below the + * License Header, with the fields enclosed by brackets [] replaced by + * your own identifying information: + * "Portions Copyrighted [year] [name of copyright owner]" + * + * If you wish your version of this file to be governed by only the CDDL + * or only the GPL Version 2, indicate your decision by adding + * "[Contributor] elects to include this software in this distribution + * under the [CDDL or GPL Version 2] license." If you do not indicate a + * single choice of license, a recipient has the option to distribute + * your version of this file under either the CDDL, the GPL Version 2 or + * to extend the choice of license to its licensees as provided above. + * However, if you add GPL Version 2 code and therefore, elected the GPL + * Version 2 license, then the option applies only if the new code is + * made subject to such option by the copyright holder. + * + * Contributor(s): + * + * Portions Copyrighted 2012 Sun Microsystems, Inc. + */ +package org.netbeans.modules.cnd.execution.api; + +import java.net.URI; +import java.util.EventObject; + +/** + * An Event object that provides information about the source of a + * connection-related event. + * + *+ * {@link ConnectionStateChangeEvent}s are sent to registered {@link ConnectionStateChangeListener}s + * when status of some connection changes.
+ * + * @see ConnectionManager + * + * @author akrasny + */ +public final class ConnectionStateChangeEvent extends EventObject { + + private static final long serialVersionUID = 1L; + private final State state; + + /** + * Constructs a new {@link ConnectionStateChangeEvent}. + * + * @param uri an URI of the connection this event belongs to. + * @param state the new {@link State} of the connection. + */ + public ConnectionStateChangeEvent(URI uri, State state) { + super(uri); + this.state = state; + } + + /** + * Returns a {@link State} this event was generated for. + * + * @return the {@link State} of the connection this event was issued for. + */ + public State getState() { + return state; + } + + /** + * Returns the {@link URI} this event relates to. + * + * @return the related {@link URI}. + */ + @Override + public URI getSource() { + return (URI) super.getSource(); + } + + /** + * Enumeration of possible {@link State}s that events are generated for. + */ + public enum State { + + /** + * Issued when a new connection is established. + */ + CONNECTION_ESTABLISHED, + /** + * Issued when a connection is implicitly terminated. + */ + CONNECTION_CLOSED, + /** + * Issued when infrastructure detects that connection is not active + * while no implicit termination was performed. + */ + CONNECTION_LOST + } +} diff --git a/cnd.execution/src/org/netbeans/modules/cnd/execution/api/ConnectionStateChangeListener.java b/cnd.execution/src/org/netbeans/modules/cnd/execution/api/ConnectionStateChangeListener.java new file mode 100644 --- /dev/null +++ b/cnd.execution/src/org/netbeans/modules/cnd/execution/api/ConnectionStateChangeListener.java @@ -0,0 +1,69 @@ +/* + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. + * + * Copyright 2012 Oracle and/or its affiliates. All rights reserved. + * + * Oracle and Java are registered trademarks of Oracle and/or its affiliates. + * Other names may be trademarks of their respective owners. + * + * The contents of this file are subject to the terms of either the GNU + * General Public License Version 2 only ("GPL") or the Common + * Development and Distribution License("CDDL") (collectively, the + * "License"). You may not use this file except in compliance with the + * License. You can obtain a copy of the License at + * http://www.netbeans.org/cddl-gplv2.html + * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the + * specific language governing permissions and limitations under the + * License. When distributing the software, include this License Header + * Notice in each file and include the License file at + * nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the GPL Version 2 section of the License file that + * accompanied this code. If applicable, add the following below the + * License Header, with the fields enclosed by brackets [] replaced by + * your own identifying information: + * "Portions Copyrighted [year] [name of copyright owner]" + * + * If you wish your version of this file to be governed by only the CDDL + * or only the GPL Version 2, indicate your decision by adding + * "[Contributor] elects to include this software in this distribution + * under the [CDDL or GPL Version 2] license." If you do not indicate a + * single choice of license, a recipient has the option to distribute + * your version of this file under either the CDDL, the GPL Version 2 or + * to extend the choice of license to its licensees as provided above. + * However, if you add GPL Version 2 code and therefore, elected the GPL + * Version 2 license, then the option applies only if the new code is + * made subject to such option by the copyright holder. + * + * Contributor(s): + * + * Portions Copyrighted 2012 Sun Microsystems, Inc. + */ +package org.netbeans.modules.cnd.execution.api; + +import java.util.EventListener; + +/** + * Used to be notified about active connections state changes. + * + * + * @author akrasny + */ +public interface ConnectionStateChangeListener extends EventListener { + + /** + * Is invoked on connection state change. + * + *It is guaranteed that events are delivered in the same order they + * occur.
+ * + *For implicit actions (connect/disconnect) events are sent + * synchronously and instantly. But there is an event that is asynchronous + * by it's nature - it is when connection is lost. In this case there could + * be a delay in event delivery until after infrastructure detects a broken + * connection.
+ * + * @param event the event that describes a state change. + */ + public void connectionStateChanged(ConnectionStateChangeEvent event); +} diff --git a/cnd.execution/src/org/netbeans/modules/cnd/execution/api/EnvironmentMap.java b/cnd.execution/src/org/netbeans/modules/cnd/execution/api/EnvironmentMap.java new file mode 100644 --- /dev/null +++ b/cnd.execution/src/org/netbeans/modules/cnd/execution/api/EnvironmentMap.java @@ -0,0 +1,461 @@ +/* + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. + * + * Copyright 2012 Oracle and/or its affiliates. All rights reserved. + * + * Oracle and Java are registered trademarks of Oracle and/or its affiliates. + * Other names may be trademarks of their respective owners. + * + * The contents of this file are subject to the terms of either the GNU + * General Public License Version 2 only ("GPL") or the Common + * Development and Distribution License("CDDL") (collectively, the + * "License"). You may not use this file except in compliance with the + * License. You can obtain a copy of the License at + * http://www.netbeans.org/cddl-gplv2.html + * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the + * specific language governing permissions and limitations under the + * License. When distributing the software, include this License Header + * Notice in each file and include the License file at + * nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the GPL Version 2 section of the License file that + * accompanied this code. If applicable, add the following below the + * License Header, with the fields enclosed by brackets [] replaced by + * your own identifying information: + * "Portions Copyrighted [year] [name of copyright owner]" + * + * If you wish your version of this file to be governed by only the CDDL + * or only the GPL Version 2, indicate your decision by adding + * "[Contributor] elects to include this software in this distribution + * under the [CDDL or GPL Version 2] license." If you do not indicate a + * single choice of license, a recipient has the option to distribute + * your version of this file under either the CDDL, the GPL Version 2 or + * to extend the choice of license to its licensees as provided above. + * However, if you add GPL Version 2 code and therefore, elected the GPL + * Version 2 license, then the option applies only if the new code is + * made subject to such option by the copyright holder. + * + * Contributor(s): + * + * Portions Copyrighted 2012 Sun Microsystems, Inc. + */ +package org.netbeans.modules.cnd.execution.api; + +import java.io.PrintStream; +import java.text.Collator; +import java.text.ParseException; +import java.util.Arrays; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashSet; +import java.util.LinkedHashMap; +import java.util.LinkedHashSet; +import java.util.Locale; +import java.util.Map; +import java.util.Map.Entry; +import java.util.Set; +import java.util.TreeMap; +import org.netbeans.modules.cnd.execution.access.EnvironmentMapAccessor; +import org.netbeans.modules.cnd.execution.util.MacroExpander; + +/** + * Map of key-value String pairs. + * + * An implementation of Map interface that can do macro expansion on insertion + * and preserves an order of insertions. + * + * The following formats of macros are supported: + *
+ * ${NAME}
+ * $NAME
+ *
+ *
+ * Not thread safe
+ *
+ * @author akrasny
+ */
+public final class EnvironmentMap implements Cloneable {
+
+ private final Comparator comparator;
+ private final EnvironmentMap baseMap;
+ private final LinkedHashMap The {@link #put(String, String)} method works as follows:
+ *
+ *
+ * EnvironmentMap m = new EnvironmentMap()
+ * m.put("ANT_HOME", "/bin");
+ * m.put("PATH", "$ANT_HOME");
+ * m.put("PATH", "${PATH}:/usr/bin");
+ *
+ *
+ * as a result the key "PATH" will be associated with the value
+ * "${ANT_HOME}:/usr/bin".
The only (possibly) altered value on insertion is the inserted value + * itself. The only macro that is expanded is the key-named macro. (See the + * above example - $ANT_HOME is not expanded in the value of PATH)
+ * + *Comparator is used for comparing key.
+ * + * @param key the key of an entry + * @param value the new value of an entry + * @return a previous value associated with the key + */ + public final String put(final String key, final String value) { + return put(key, value, true); + } + + // XXX reduce visibility of this + public final String put(final String key, final String value, boolean expand) { + if (value == null) { + throw new NullPointerException("Attempt to set a null value"); // NOI18N + } + String result = value; + + + String fixedKey = fixKey(key); + + if (expand) { + try { + result = MacroExpander.expandMacros(value, toMap()); + } catch (ParseException ex) { + } + } + removedKeys.remove(fixedKey); + return ownMap.put(fixedKey, result); + + } + + protected Comparator getComparator() { + return comparator; + } + + /** + * Returns a value associated with a key. + * + * @param key the key to get value for or {@code null} if no value is + * associated. + * @return the value associated with a key. + */ + public final String get(final String key) { + String k = fixKey(key); + return getImpl(k); + } + + /** + * Appends provided path to the value of the specified variable. + * + *As a result a {@code path} will be appended to a value of variable + * with the name {@code name}. If the same path was already in the list of + * paths the value of the variable will remain unchanged.
+ * + *If the variable named {@code name} was not defined yet before this + * method invocation, the variable will have the only entry - this new + * path.
+ * + * @param name the name of the variable to change. + * @param path the path element to append to the list of path elements. + * Could be {@code null}, but in this case method does nothing. + */ + public void appendPath(String name, String path) { + appendPath(name, path, true); + } + + // XXX reduce visibility of this + public void appendPath(String name, String path, boolean expand) { + if (path == null) { + return; + } + + String oldpath = get(name); + String newPath = (oldpath == null ? "" : oldpath + (pathSeparator)) + path; // NOI18N + put(name, reducePath(newPath), expand); + } + + /** + * Prepends provided path to the value of the specified variable. + * + *As a result a variable with the name {@code name} will contain {@code path} + * at the first place. Also if the same path was already in the list of + * paths, that 'old' entry will be removed to avoid unneeded + * duplications.
+ * + *If specified variable was not defined yet before this method + * invocation, it will have the only entry - this new path.
+ * + * @param name the name of the variable to change. + * @param path the path element to add to the list of path elements. Could + * be {@code null}, but in this case method does nothing. + */ + public void prependPath(String name, String path) { + prependPath(name, path, true); + } + + // XXX reduce visibility of this + public void prependPath(String name, String path, boolean expand) { + if (path == null) { + return; + } + + String oldpath = get(name); + String newPath = path + (oldpath == null ? "" : (pathSeparator) + oldpath); // NOI18N + put(name, reducePath(newPath), expand); + } + + /** + * A string representation of the map. + * + * @return the string representation. + */ + @Override + public final String toString() { + StringBuilder buf = new StringBuilder(); + buf.append("{"); // NOI18N + + for (Map.EntryEach NativeProcessBuilder instance manages a collection of process + * attributes. The {@link #call()} method creates a new {@link NativeProcess} + * instance with those attributes. The {@link #call()} method can be invoked + * repeatedly from the same instance to create new processes with identical or + * related attributes.
+ * + *There are several common attributes that could be configured directly by + * invoking appropriate methods. Additional {@link Connection}-specific + * attributes could be provided by a specific implementation. Access to those + * attributes is done using {@link #getSupportedProperties()} and + * {@link #setProperty(String, Object)} methods.
+ * + *Modifying a NativeProcessBuilder's attributes will affect processes + * subsequently started by it's {@link #call()} method, but will never affect + * previously started processes.
+ * + *This class is NOT thread-safe.
+ * + * @see ConnectionManager + * @author akrasny + */ +public final class NativeProcessBuilder implements CallableAdded listener will be passed to every subsequently created + * NativeProcess. Already running NativeProcess will not see any changes in + * the listeners list.
+ * + * @param listener the {@link ProcessStateChangeListener} to add. + */ + public NativeProcessBuilder addProcessListener(ProcessStateChangeListener listener) { + listeners.add(listener); + return this; + } + + public NativeProcessBuilder removeProcessListener(ProcessStateChangeListener listener) { + listeners.remove(listener); + return this; + } + + /** + * Sets the Command attribute. + * + *Sets an executable and arguments of the process to start. This method + * does a copy of the command list. No any validation is performed.
+ * + *Note that setting a command with this method erases any data + * configured with the {@link #setShellScript(String, String)} method.
+ * + * + * @param executable the executable to start. + * @param arguments the list of arguments that will be passed to the + * executable. + * @return This process builder. + * @see #setShellScript(String, String) + */ + public NativeProcessBuilder setCommand(String executable, String... arguments) { + command = new ArrayListDefines a shell script (text) that should be interpreted by the + * specified shell.
+ * + *In case of using {@code /bin/sh}, that would be the same as calling + * {@code setCommand("/bin/sh", "-s")} and writing a script to it's input + * stream.
+ * + *Note that setting a command with this method erases any data + * configured with the {@link #setCommand(String, String[])} method.
+ * + * @param shell the shell to use. If {@code null}, then default user's shell + * is used. + * @param script the script to be passed to the shell. + * @return This process builder. + * @see #setShellScript(String, String) + */ + public NativeProcessBuilder setShellScript(String shell, String script) { + this.shell = shell; + this.shellScript = script; + command = null; + return this; + } + + /** + * Configures a working directory attribute. + * + *Process subsequently created by the call() method on this builder + * will be executed with this directory as a current working dir.
+ * + *The default value is undefined.
+ * + * @param workingDirectory working directory to start a process in. + * @return This process builder. + */ + public NativeProcessBuilder setWorkingDirectory(String workingDirectory) { + this.wdir = workingDirectory; + return this; + } + + /** + * Configures a error stream redirection attribute. + * + *
If this property is true, then any error output generated by processes + * subsequently started by this builder will be merged with the standard + * output, so that both can be read using a stream returned by + * {@code NativeProcess.getInputStream()} method.
+ * + *The initial value is false.
+ * + * @param redirectErrorStream the new value of the attribute. + * @return This process builder. + */ + public NativeProcessBuilder redirectErrorStream(boolean redirectErrorStream) { + this.redirectError = redirectErrorStream; + return this; + } + + /** + * Returns a string map view of this process builder's environment. + * + *Whenever a process builder is created, the environment is initialized + * to a copy of the {@link Connection}'s environment (if applicable). + * Processes subsequently started by this builder will use this map as their + * environment.
+ * + * @return This process builder's environment. + */ + public EnvironmentMap getEnvironmentMap() { + return environmentMap; + } + + @Override + public Lookup getLookup() { + return new ProxyLookup(Lookups.fixed(stateConfig, shellConfig), creator.getLookup()); + } + + /** + * Starts a new process using the attributes of this process builder. + * + * @return a new {@link NativeProcess}. + * @throws NativeExecutionException if process cannot be created. + */ + @Override + public Process call() throws NativeExecutionException { + if (!connection.isConnected()) { + throw new BrokenConnectionException(connection.getURI()); + } + + final AtomicReference+ * Process has determinated order of states it can be set to: + * INITIAL ---> STARTING ---> RUNNING ---> FINISHED + * |-> CANCELLED |-> CENCELLED |-> CANCELLED + * |-> ERROR |-> ERROR |-> ERROR + * + * CANCELLED, ERROR and FINISHED are terminal states. + *+ * + *
It is guaranteed that:
Note: listeners are notified asynchronously relative a process + * itself. This means that at a time of event delivery the real state of + * a process may already differ.
+ * + * @param evt the event this notification is about + */ + public void processStateChanged(ProcessStateChangeEvent evt); + } + + /** + * ProcessStateChangeEvent is used to notify interested parties that state + * of the source's process has changed. + * + * @author akrasny + */ + public static final class ProcessStateChangeEvent extends EventObject { + + private static final long serialVersionUID = 1L; + private final ProcessState.State state; + private final long ts; + + /** + * Constructs a new ProcessStateChangeEvent event. + * + * @param process the process that originated the event. + * @param state the new state of the process. + */ + public ProcessStateChangeEvent(Process process, ProcessState.State state) { + this(process, state, System.nanoTime()); + } + + /** + * Constructs a new ProcessStateChangeEvent event. + * + * @param process the process that originated the event. + * @param state the new state of the process. + * @param nanoTime the exact time of the event. + */ + public ProcessStateChangeEvent(Process process, ProcessState.State state, long nanoTime) { + super(process); + this.state = state; + this.ts = nanoTime; + } + + /** + * Returns a state of the process on the moment of this event creation. + * + * @return the state of the process on the moment of this event + * creation. + */ + public ProcessState.State getState() { + return state; + } + + /** + * Returns the source {@link Process} for this event. + * + * @return the event source + */ + @Override + public Process getSource() { + return (Process) super.getSource(); + } + + /** + * Returns the timestamp of when this event occurred. + * + * @return this event's timestamp. + */ + public long getEventNanoTime() { + return ts; + } + } +} diff --git a/cnd.execution/src/org/netbeans/modules/cnd/execution/api/process/ProcessState.java b/cnd.execution/src/org/netbeans/modules/cnd/execution/api/process/ProcessState.java new file mode 100644 --- /dev/null +++ b/cnd.execution/src/org/netbeans/modules/cnd/execution/api/process/ProcessState.java @@ -0,0 +1,107 @@ +/* + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. + * + * Copyright 2012 Oracle and/or its affiliates. All rights reserved. + * + * Oracle and Java are registered trademarks of Oracle and/or its affiliates. + * Other names may be trademarks of their respective owners. + * + * The contents of this file are subject to the terms of either the GNU + * General Public License Version 2 only ("GPL") or the Common + * Development and Distribution License("CDDL") (collectively, the + * "License"). You may not use this file except in compliance with the + * License. You can obtain a copy of the License at + * http://www.netbeans.org/cddl-gplv2.html + * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the + * specific language governing permissions and limitations under the + * License. When distributing the software, include this License Header + * Notice in each file and include the License file at + * nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the GPL Version 2 section of the License file that + * accompanied this code. If applicable, add the following below the + * License Header, with the fields enclosed by brackets [] replaced by + * your own identifying information: + * "Portions Copyrighted [year] [name of copyright owner]" + * + * If you wish your version of this file to be governed by only the CDDL + * or only the GPL Version 2, indicate your decision by adding + * "[Contributor] elects to include this software in this distribution + * under the [CDDL or GPL Version 2] license." If you do not indicate a + * single choice of license, a recipient has the option to distribute + * your version of this file under either the CDDL, the GPL Version 2 or + * to extend the choice of license to its licensees as provided above. + * However, if you add GPL Version 2 code and therefore, elected the GPL + * Version 2 license, then the option applies only if the new code is + * made subject to such option by the copyright holder. + * + * Contributor(s): + * + * Portions Copyrighted 2012 Sun Microsystems, Inc. + */ +package org.netbeans.modules.cnd.execution.api.process; + +import org.openide.util.Lookup; + +/** + * + * @author Petr Hejl + */ +public abstract class ProcessState { + + private static ProcessState find(Process process) { + if (process instanceof Lookup.Provider) { + Lookup.Provider p = (Lookup.Provider) process; + return p.getLookup().lookup(ProcessState.class); + } + return null; + } + + public static boolean isSupported(Process process) { + return find(process) != null; + } + + public static State getState(Process process) { + ProcessState processState = find(process); + if (processState != null) { + return processState.getState(); + } + return null; + } + + protected abstract State getState(); + + /** + * Enumerates all possible states of a {@link Process}. + */ + public enum State { + + /** + * Native process is in an Initial state. This means that it has not + * been started yet. + */ + INITIAL, + /** + * Native process is starting. This means that it has been submitted, + * but no PID is received so far. + */ + STARTING, + /** + * Native process runs. This means that process successfully started and + * it's PID is already known. + */ + RUNNING, + /** + * Native process is done, but exit status is not available yet. + */ + FINISHING, + /** + * Native process exited. + */ + FINISHED, + /** + * Native process submission failed due to some exception. + */ + ERROR + } +} diff --git a/cnd.execution/src/org/netbeans/modules/cnd/execution/api/process/package-info.java b/cnd.execution/src/org/netbeans/modules/cnd/execution/api/process/package-info.java new file mode 100644 --- /dev/null +++ b/cnd.execution/src/org/netbeans/modules/cnd/execution/api/process/package-info.java @@ -0,0 +1,51 @@ +/* + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. + * + * Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved. + * + * Oracle and Java are registered trademarks of Oracle and/or its affiliates. + * Other names may be trademarks of their respective owners. + * + * The contents of this file are subject to the terms of either the GNU + * General Public License Version 2 only ("GPL") or the Common + * Development and Distribution License("CDDL") (collectively, the + * "License"). You may not use this file except in compliance with the + * License. You can obtain a copy of the License at + * http://www.netbeans.org/cddl-gplv2.html + * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the + * specific language governing permissions and limitations under the + * License. When distributing the software, include this License Header + * Notice in each file and include the License file at + * nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the GPL Version 2 section of the License file that + * accompanied this code. If applicable, add the following below the + * License Header, with the fields enclosed by brackets [] replaced by + * your own identifying information: + * "Portions Copyrighted [year] [name of copyright owner]" + * + * Contributor(s): + * + * The Original Software is NetBeans. The Initial Developer of the Original + * Software is Sun Microsystems, Inc. Portions Copyright 1997-2007 Sun + * Microsystems, Inc. All Rights Reserved. + * + * If you wish your version of this file to be governed by only the CDDL + * or only the GPL Version 2, indicate your decision by adding + * "[Contributor] elects to include this software in this distribution + * under the [CDDL or GPL Version 2] license." If you do not indicate a + * single choice of license, a recipient has the option to distribute + * your version of this file under either the CDDL, the GPL Version 2 or + * to extend the choice of license to its licensees as provided above. + * However, if you add GPL Version 2 code and therefore, elected the GPL + * Version 2 license, then the option applies only if the new code is + * made subject to such option by the copyright holder. + */ + +/** + * The API supporting enhanced functionality for + * a {@link java.lang.Process}. Could be moved to org.netbeans.api.extexecution.process + * in future. + */ +package org.netbeans.modules.cnd.execution.api.process; + diff --git a/cnd.execution/src/org/netbeans/modules/cnd/execution/common/Bundle.properties b/cnd.execution/src/org/netbeans/modules/cnd/execution/common/Bundle.properties new file mode 100644 --- /dev/null +++ b/cnd.execution/src/org/netbeans/modules/cnd/execution/common/Bundle.properties @@ -0,0 +1,43 @@ +# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. +# +# Copyright 2012 Oracle and/or its affiliates. All rights reserved. +# +# Oracle and Java are registered trademarks of Oracle and/or its affiliates. +# Other names may be trademarks of their respective owners. +# +# The contents of this file are subject to the terms of either the GNU +# General Public License Version 2 only ("GPL") or the Common +# Development and Distribution License("CDDL") (collectively, the +# "License"). You may not use this file except in compliance with the +# License. You can obtain a copy of the License at +# http://www.netbeans.org/cddl-gplv2.html +# or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the +# specific language governing permissions and limitations under the +# License. When distributing the software, include this License Header +# Notice in each file and include the License file at +# nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this +# particular file as subject to the "Classpath" exception as provided +# by Oracle in the GPL Version 2 section of the License file that +# accompanied this code. If applicable, add the following below the +# License Header, with the fields enclosed by brackets [] replaced by +# your own identifying information: +# "Portions Copyrighted [year] [name of copyright owner]" +# +# If you wish your version of this file to be governed by only the CDDL +# or only the GPL Version 2, indicate your decision by adding +# "[Contributor] elects to include this software in this distribution +# under the [CDDL or GPL Version 2] license." If you do not indicate a +# single choice of license, a recipient has the option to distribute +# your version of this file under either the CDDL, the GPL Version 2 or +# to extend the choice of license to its licensees as provided above. +# However, if you add GPL Version 2 code and therefore, elected the GPL +# Version 2 license, then the option applies only if the new code is +# made subject to such option by the copyright holder. +# +# Contributor(s): +# +# Portions Copyrighted 2012 Sun Microsystems, Inc. + +Connector.progress.message=Connection progress +Connector.progress.connectTo=Connecting to {0} ... +Connector.progress.fetchingInfo=Getting connection info diff --git a/cnd.execution/src/org/netbeans/modules/cnd/execution/common/ConnectionListeners.java b/cnd.execution/src/org/netbeans/modules/cnd/execution/common/ConnectionListeners.java new file mode 100644 --- /dev/null +++ b/cnd.execution/src/org/netbeans/modules/cnd/execution/common/ConnectionListeners.java @@ -0,0 +1,204 @@ +/* + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. + * + * Copyright 2012 Oracle and/or its affiliates. All rights reserved. + * + * Oracle and Java are registered trademarks of Oracle and/or its affiliates. + * Other names may be trademarks of their respective owners. + * + * The contents of this file are subject to the terms of either the GNU + * General Public License Version 2 only ("GPL") or the Common + * Development and Distribution License("CDDL") (collectively, the + * "License"). You may not use this file except in compliance with the + * License. You can obtain a copy of the License at + * http://www.netbeans.org/cddl-gplv2.html + * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the + * specific language governing permissions and limitations under the + * License. When distributing the software, include this License Header + * Notice in each file and include the License file at + * nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the GPL Version 2 section of the License file that + * accompanied this code. If applicable, add the following below the + * License Header, with the fields enclosed by brackets [] replaced by + * your own identifying information: + * "Portions Copyrighted [year] [name of copyright owner]" + * + * If you wish your version of this file to be governed by only the CDDL + * or only the GPL Version 2, indicate your decision by adding + * "[Contributor] elects to include this software in this distribution + * under the [CDDL or GPL Version 2] license." If you do not indicate a + * single choice of license, a recipient has the option to distribute + * your version of this file under either the CDDL, the GPL Version 2 or + * to extend the choice of license to its licensees as provided above. + * However, if you add GPL Version 2 code and therefore, elected the GPL + * Version 2 license, then the option applies only if the new code is + * made subject to such option by the copyright holder. + * + * Contributor(s): + * + * Portions Copyrighted 2012 Sun Microsystems, Inc. + */ +package org.netbeans.modules.cnd.execution.common; + +import java.net.URI; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import org.netbeans.modules.cnd.execution.api.Connection; +import org.netbeans.modules.cnd.execution.api.ConnectionManager; +import org.netbeans.modules.cnd.execution.api.ConnectionStateChangeEvent; +import org.netbeans.modules.cnd.execution.api.ConnectionStateChangeEvent.State; +import org.netbeans.modules.cnd.execution.api.ConnectionStateChangeListener; +import org.netbeans.modules.cnd.execution.util.URIMatcher; +import org.openide.util.RequestProcessor; +import org.openide.util.RequestProcessor.Task; +import org.openide.util.WeakSet; + +/** + * + * @author akrasny + */ +public final class ConnectionListeners { + + private static final RequestProcessor RP = new RequestProcessor("ConnectionListeners", 1); // NOI18N + private static final MapOutput to the stream is piped into the standard input stream of the + * process represented by this {@link NativeProcess} object.
+ * + * @return the output stream connected to the normal input of the process. + */ + @Override + public OutputStream getOutputStream() { + return outputStream; + } + + /** + * Gets the input stream of the process. + * + *The stream obtains data piped from the standard output stream of the + * process represented by this {@link NativeProcess} object.
+ * + * @return the input stream connected to the normal output of the process. + */ + @Override + public InputStream getInputStream() { + return inputStream; + } + + /** + * Gets the error stream of the process. + * + *The stream obtains data piped from the error output stream of the + * process represented by this {@link NativeProcess} object.
+ * + * @return the input stream connected to the error stream of the process. + */ + @Override + public InputStream getErrorStream() { + return errorStream; + } + + /** + * Causes the current thread to wait, if necessary, until the process + * represented by this {@link NativeProcess} object has terminated. + * + *This method returns immediately if the process has already terminated. + * If the process has not yet terminated, the calling thread will be blocked + * until the process exits.
+ * + * @return the exit value of the process. By convention, 0 indicates normal + * termination. + * @throws InterruptedException if the current thread is interrupted by + * another thread while it is waiting, then the wait is ended and an + * InterruptedException is thrown. + */ + @Override + public int waitFor() throws InterruptedException { + try { + return waitTask.get(); + } catch (java.util.concurrent.ExecutionException ex) { + // Should not happen. + // Exception here could mean that there are problems in + // implementation + Exceptions.printStackTrace(ex); + throw new InternalError(ex.toString()); + } + } + + /** + * Returns the exit value for the process. + * + *{@link IllegalThreadStateException} is thrown if process is not + * terminated yet.
+ * + * @return the exit value of the process represented by this {@link NativeProcess} + * object. By convention, the value {@code 0} indicates normal termination. + */ + @Override + public int exitValue() { + if (!waitTask.isDone()) { + // Process not started/finished yet... + throw new IllegalThreadStateException(); + } + + try { + return waitTask.get(); + } catch (InterruptedException ex) { + // Should not happen + Thread.interrupted(); + return -1; + } catch (java.util.concurrent.ExecutionException ex) { + // Should not happen. + // Exception here could mean that there are problems in + // implementation + Exceptions.printStackTrace(ex); + throw new InternalError(ex.toString()); + } + } + + /** + * Kills the subprocess. + * + * The subprocess represented by this {@link NativeProcess} object is + * forcibly terminated. + */ + @Override + public void destroy() { + killProcess(); + } + + /** + * Returns a human-readable identification of the + * {@link NativeProcess}. + * + * @return string that identifies the {@link NativeProcess}. + */ + @Override + public String toString() { + return "/PID=" + getPID() + "/ " + processImpl.toString(); // NOI18N + } + + @Override + public Lookup getLookup() { + return lookup; + } + + private static Charset getProcessOutputCharset(Process process) { + return getCharset("outputCharset", process); // NOI18N + } + + private static Charset getProcessInputCharset(Process process) { + return getCharset("inputCharset", process); // NOI18N + } + + private static Charset getCharset(String paramName, Process process) { + + Charset charset = null; + + if (process instanceof NativeProcess) { + NativeProcess np = (NativeProcess) process; + NativeProcessAccessor access = NativeProcessAccessor.getDefault(); + NativeProcessParams params = access.getProcessParams(np); + charset = null; // params.getProperty(Charset.class, paramName); + } + + if (charset == null || !Charset.isSupported(charset.name())) { + charset = Charset.isSupported("UTF-8") // NOI18N + ? Charset.forName("UTF-8") : // NOI18N + Charset.defaultCharset(); // NOI18N + ExecutionLogger.getInstance().log(Level.FINE, + "{0} is not set or is not supported - use {1}", // NOI18N + new Object[]{paramName, charset.name()}); + } + + return charset; + } + + private class NativeProcessId extends ProcessId { + + @Override + protected Integer getId() { + return NativeProcess.this.getPID(); + } + } + + private class NativeProcessState extends ProcessState { + + @Override + protected State getState() { + return NativeProcess.this.getState(); + } + } + + private class NativeProcessCharset extends ProcessCharset { + + @Override + protected Charset getInputCharset() { + return getProcessInputCharset(NativeProcess.this); + } + + @Override + protected Charset getOutputCharset() { + return getProcessOutputCharset(NativeProcess.this); + } + + @Override + protected Charset getErrorCharset() { + return getProcessOutputCharset(NativeProcess.this); + } + } + + private class NativeProcessSignal extends ProcessSignal { + + @Override + protected void signal(Signal signal) { + SignalUtils.signal(NativeProcess.this, SignalUtils.translate(signal)); + } + + @Override + protected void signalGroup(Signal signal) { + SignalUtils.signalGrp(NativeProcess.this, SignalUtils.translate(signal)); + } + } + + private static class NativeProcessAccessorImpl extends NativeProcessAccessor { + + @Override + public Connection getConnection(NativeProcess process) { + return process.params.getConnection(); + } + + @Override + public NativeProcessParams getProcessParams(NativeProcess process) { + return process.params; + } + } +} diff --git a/cnd.execution/src/org/netbeans/modules/cnd/execution/common/ProcessStateChangeNotifier.java b/cnd.execution/src/org/netbeans/modules/cnd/execution/common/ProcessStateChangeNotifier.java new file mode 100644 --- /dev/null +++ b/cnd.execution/src/org/netbeans/modules/cnd/execution/common/ProcessStateChangeNotifier.java @@ -0,0 +1,53 @@ +/* + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. + * + * Copyright 2012 Oracle and/or its affiliates. All rights reserved. + * + * Oracle and Java are registered trademarks of Oracle and/or its affiliates. + * Other names may be trademarks of their respective owners. + * + * The contents of this file are subject to the terms of either the GNU + * General Public License Version 2 only ("GPL") or the Common + * Development and Distribution License("CDDL") (collectively, the + * "License"). You may not use this file except in compliance with the + * License. You can obtain a copy of the License at + * http://www.netbeans.org/cddl-gplv2.html + * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the + * specific language governing permissions and limitations under the + * License. When distributing the software, include this License Header + * Notice in each file and include the License file at + * nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the GPL Version 2 section of the License file that + * accompanied this code. If applicable, add the following below the + * License Header, with the fields enclosed by brackets [] replaced by + * your own identifying information: + * "Portions Copyrighted [year] [name of copyright owner]" + * + * If you wish your version of this file to be governed by only the CDDL + * or only the GPL Version 2, indicate your decision by adding + * "[Contributor] elects to include this software in this distribution + * under the [CDDL or GPL Version 2] license." If you do not indicate a + * single choice of license, a recipient has the option to distribute + * your version of this file under either the CDDL, the GPL Version 2 or + * to extend the choice of license to its licensees as provided above. + * However, if you add GPL Version 2 code and therefore, elected the GPL + * Version 2 license, then the option applies only if the new code is + * made subject to such option by the copyright holder. + * + * Contributor(s): + * + * Portions Copyrighted 2012 Sun Microsystems, Inc. + */ +package org.netbeans.modules.cnd.execution.common; + +import org.netbeans.modules.cnd.execution.api.process.ProcessState.State; + +/** + * + * @author akrasny + */ +public interface ProcessStateChangeNotifier { + + public void notifyProcessStateChange(final State newProcessState); +} diff --git a/cnd.execution/src/org/netbeans/modules/cnd/execution/common/SignalUtils.java b/cnd.execution/src/org/netbeans/modules/cnd/execution/common/SignalUtils.java new file mode 100644 --- /dev/null +++ b/cnd.execution/src/org/netbeans/modules/cnd/execution/common/SignalUtils.java @@ -0,0 +1,285 @@ +/* + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. + * + * Copyright 2012 Oracle and/or its affiliates. All rights reserved. + * + * Oracle and Java are registered trademarks of Oracle and/or its affiliates. + * Other names may be trademarks of their respective owners. + * + * The contents of this file are subject to the terms of either the GNU + * General Public License Version 2 only ("GPL") or the Common + * Development and Distribution License("CDDL") (collectively, the + * "License"). You may not use this file except in compliance with the + * License. You can obtain a copy of the License at + * http://www.netbeans.org/cddl-gplv2.html + * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the + * specific language governing permissions and limitations under the + * License. When distributing the software, include this License Header + * Notice in each file and include the License file at + * nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the GPL Version 2 section of the License file that + * accompanied this code. If applicable, add the following below the + * License Header, with the fields enclosed by brackets [] replaced by + * your own identifying information: + * "Portions Copyrighted [year] [name of copyright owner]" + * + * If you wish your version of this file to be governed by only the CDDL + * or only the GPL Version 2, indicate your decision by adding + * "[Contributor] elects to include this software in this distribution + * under the [CDDL or GPL Version 2] license." If you do not indicate a + * single choice of license, a recipient has the option to distribute + * your version of this file under either the CDDL, the GPL Version 2 or + * to extend the choice of license to its licensees as provided above. + * However, if you add GPL Version 2 code and therefore, elected the GPL + * Version 2 license, then the option applies only if the new code is + * made subject to such option by the copyright holder. + * + * Contributor(s): + * + * Portions Copyrighted 2012 Sun Microsystems, Inc. + */ +package org.netbeans.modules.cnd.execution.common; + +import java.net.URI; +import java.util.EnumMap; +import java.util.Map; +import org.netbeans.api.extexecution.process.ProcessSignal; +import org.netbeans.modules.cnd.execution.access.ConnectionAccessor; +import org.netbeans.modules.cnd.execution.access.NativeProcessAccessor; +import org.netbeans.modules.cnd.execution.api.Connection; +import org.netbeans.modules.cnd.execution.api.ConnectionManager; +import org.netbeans.modules.cnd.execution.spi.support.SignalSupport; +import org.netbeans.modules.cnd.execution.spi.support.SignalSupportProvider; +import org.netbeans.modules.cnd.execution.util.HostInfo; +import org.openide.util.Lookup; + +/** + * Some systems support Signal mechanism for sending asynchronous events to a + * given process. + * + * This is an API class for delivering signals to a process. + * + * Note: signals-related functionality could be unavailable on some systems or + * irrelevant to some processes. + * + * @author akrasny + */ +public final class SignalUtils { + + private static final NativeProcessAccessor access = NativeProcessAccessor.getDefault(); + + private SignalUtils() { + } + + /** + * Send a specified signal to a process. + * + * @param process the process to signal + * @param signal the signal to send + * @throws UnsupportedOperationException + */ + public static void signal(NativeProcess process, Signal signal) throws UnsupportedOperationException { + Connection c = access.getConnection(process); + SignalSupport ss = getSignalSupport(c); + if (ss != null) { + ss.signal(process, signal); + } + } + + /** + * Send a signal with attached value to a process. + * + * @param process the process to signal + * @param signal the signal to send + * @param value the value to attach to a signal + * @throws UnsupportedOperationException + */ + public static void sigqueue(NativeProcess process, Signal signal, int value) throws UnsupportedOperationException { + Connection c = access.getConnection(process); + SignalSupport ss = getSignalSupport(c); + if (ss != null) { + ss.sigqueue(process, signal, value); + } + } + + /** + * Send a signal to a whole group a process belongs to. + * + * @param process the process (and it's group) to signal + * @param signal the signal to send + * @throws UnsupportedOperationException + */ + public static void signalGrp(NativeProcess process, SignalUtils.Signal signal) throws UnsupportedOperationException { + Connection c = access.getConnection(process); + SignalSupport ss = getSignalSupport(c); + if (ss != null) { + ss.signalGrp(process, signal); + } + } + + /** + * Send a specified signal to a PID in context of the passed Connection. + * + * @param destination the context URI + * @param pid the PID of the process to send signal to + * @param signal the signal to send + * @throws UnsupportedOperationException + */ + public void signal(URI destination, int pid, SignalUtils.Signal signal) throws UnsupportedOperationException { + SignalSupport ss = getSignalSupport(destination); + if (ss != null) { + ss.signal(pid, signal); + } + } + + /** + * Send a specified signal with an attached value to a PID in context of the + * passed Connection. + * + * @param destination the context URI + * @param pid the PID of the process to send signal to + * @param signal the signal to send + * @param value the value to attach to the signal + * @throws UnsupportedOperationException + */ + public void sigqueue(URI destination, int pid, SignalUtils.Signal signal, int value) throws UnsupportedOperationException { + SignalSupport ss = getSignalSupport(destination); + if (ss != null) { + ss.sigqueue(pid, signal, value); + } + } + + /** + * Send a signal to a whole group a process identified by PID belongs to in + * context of the passed Connection. + * + * @param destination the context URI + * @param pid the PID of the process to send signal to (as well as to it's + * group) + * @param signal the signal to send + * @throws UnsupportedOperationException + */ + public void signalGrp(URI destination, int pid, SignalUtils.Signal signal) throws UnsupportedOperationException { + SignalSupport ss = getSignalSupport(destination); + if (ss != null) { + ss.signalGrp(pid, signal); + } + } + + private static SignalSupport getSignalSupport(Connection connection) { + Lookup lookup = ConnectionAccessor.getDefault().getConnectionLookup(connection); + if (lookup == null) { + throw new UnsupportedOperationException(); + } + + SignalSupportProvider signalSupportProvider = lookup.lookup(SignalSupportProvider.class); + if (signalSupportProvider == null) { + throw new UnsupportedOperationException(); + } + + return signalSupportProvider.getSignalSupport(connection); + } + + private static SignalSupport getSignalSupport(URI destination) throws UnsupportedOperationException { + Connection connection = ConnectionManager.getConnection(destination); + if (connection == null) { + return null; + } + return getSignalSupport(connection); + } + + private static Map{@link AuthDataProvider} has a set of constants that represent commonly + * used identifiers for some authorization/authentication info.
+ * + *The data that is required to establish a connection depends on a nature + * of the connection and features supported by a {@link ConnectorImplementation}. + * In a simple case this could be just a username and a password. In other cases + * this could be a location of some secret file, passphrase or any other + * data.
+ * + *In some cases implementor could extract needed information from the + * destination URI. In other cases it could look into some database or ask user + * to provide some input.
+ * + *Possible usage: + *
+ * Connection c = ConnectionManager.connect(new URI("ssh://tester@testhost"), new AuthDataProvider {
+ *
+ * public T getProperty(URI uri, Class clazz, String name, Object... misc) {
+ * Object result = null;
+ *
+ * if (String.class.equals(clazz) && "KnownHostsFile".equals(name)) {
+ * result = System.getProperty("user.home") + "/.ssh/known_hosts";
+ * } else if (char[].class.equals(clazz) && AuthDataProvider.PASSWORD.equals(name)) {
+ * result = new char[]{'t', 'e', 's', 't', 'e', 'r'};
+ * }
+ *
+ * return clazz.cast(result);
+ * }
+ * });
+ *
+ *
+ *
+ * @author akrasny
+ */
+public interface AuthDataProvider {
+
+ /**
+ * Common identifier used for requesting a username.
+ */
+ public static final String USERNAME = "username"; // NOI18N
+ /**
+ * Common identifier used for requesting a user password.
+ */
+ public static final String PASSWORD = "password"; // NOI18N
+ /**
+ * Common identifier used for requesting a host name.
+ */
+ public static final String HOST = "host"; // NOI18N
+ /**
+ * Common identifier used for requesting a port number.
+ */
+ public static final String PORT = "port"; // NOI18N
+ /**
+ * Common identifier used for requesting a User Interaction facility.
+ */
+ public static final String USER_INTERACTION = "userinteraction"; // NOI18N
+
+ /**
+ * Returns a requested property of a specified class or {@code null} if no
+ * property available and could not be retrieved.
+ *
+ * It is guaranteed that this method is called from outside the EDT.
+ * Implementor could initiate UI interaction with a user to get needed
+ * input.
For now this lookup is not exposed to the API users. It is used by + * the infrastructure to get implementation of SPI services providers for + * the connection.
+ * + * @return the {@link Lookup} associated with this connection. + * + * @see ConnectionInfoProvider + * @see SignalSupportProvider + */ + public Lookup getLookup(); + + /** + * A request to close the connection. + */ + public void disconnect(); + + /** + * Returns an actual URI this connection is associated with. + * + * @return an URI this connection is associated with. + */ + public URI getURI(); + + /** + * Tests if the connection is alive. + * + * @return true if connection is established, false otherwise. + */ + public boolean isConnected(); +} diff --git a/cnd.execution/src/org/netbeans/modules/cnd/execution/spi/ConnectorImplementation.java b/cnd.execution/src/org/netbeans/modules/cnd/execution/spi/ConnectorImplementation.java new file mode 100644 --- /dev/null +++ b/cnd.execution/src/org/netbeans/modules/cnd/execution/spi/ConnectorImplementation.java @@ -0,0 +1,93 @@ +/* + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. + * + * Copyright 2012 Oracle and/or its affiliates. All rights reserved. + * + * Oracle and Java are registered trademarks of Oracle and/or its affiliates. + * Other names may be trademarks of their respective owners. + * + * The contents of this file are subject to the terms of either the GNU + * General Public License Version 2 only ("GPL") or the Common + * Development and Distribution License("CDDL") (collectively, the + * "License"). You may not use this file except in compliance with the + * License. You can obtain a copy of the License at + * http://www.netbeans.org/cddl-gplv2.html + * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the + * specific language governing permissions and limitations under the + * License. When distributing the software, include this License Header + * Notice in each file and include the License file at + * nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the GPL Version 2 section of the License file that + * accompanied this code. If applicable, add the following below the + * License Header, with the fields enclosed by brackets [] replaced by + * your own identifying information: + * "Portions Copyrighted [year] [name of copyright owner]" + * + * If you wish your version of this file to be governed by only the CDDL + * or only the GPL Version 2, indicate your decision by adding + * "[Contributor] elects to include this software in this distribution + * under the [CDDL or GPL Version 2] license." If you do not indicate a + * single choice of license, a recipient has the option to distribute + * your version of this file under either the CDDL, the GPL Version 2 or + * to extend the choice of license to its licensees as provided above. + * However, if you add GPL Version 2 code and therefore, elected the GPL + * Version 2 license, then the option applies only if the new code is + * made subject to such option by the copyright holder. + * + * Contributor(s): + * + * Portions Copyrighted 2012 Sun Microsystems, Inc. + */ +package org.netbeans.modules.cnd.execution.spi; + +import java.io.IOException; +import java.net.URI; +import org.netbeans.modules.cnd.execution.api.Connection; +import org.netbeans.modules.cnd.execution.api.ConnectionManager; +import org.netbeans.modules.cnd.execution.api.NativeExecutionException; + +/** + * SPI for providing a way of {@link Connection} establishment. + * + * SPI implementation must be registers in the global lookup within a
+ * {@code "ConnectionService/
Once the {@link ConnectionManager} is asked to establish a new connection + * with the destination identified by an URI, it extracts a scheme part + * of the URI and looks for an implementor of this SPI in the corresponding + * lookup path to pass control over to it.
+ * + * @author akrasny + */ +public interface ConnectorImplementation { + + /** + * A request to establish a new connection. + * + *It is guaranteed that:
Implementation should return a new instance on each subsequent + * call.
+ * + *It is not required that ConnectorImplementation uses the originally passed URI + * for establishing a connection. ConnectorImplementation may choose to re-direct a + * request to a different connector with a different URI.
+ * + *Normally ConnectorImplementation should not directly interact with a user. + * ConnectorImplementation just asks authDataProvider to provide all needed + * information.
+ * + * + * @param uri an URI of the requested destination. + * @param authDataProvider the provider of information needed for connection + * establishment. + * @return a new instance of {@link ConnectionImplementation} that represents newly + * established connection. + * @throws NativeExecutionException is thrown if connection cannot be + * established for some reason. + * @throws InterruptedException if calling thread was interrupted. + */ + public ConnectionImplementation connectTo(final URI uri, final AuthDataProvider authDataProvider) throws InterruptedException, IOException; +} diff --git a/cnd.execution/src/org/netbeans/modules/cnd/execution/spi/NativeProcessCreator.java b/cnd.execution/src/org/netbeans/modules/cnd/execution/spi/NativeProcessCreator.java new file mode 100644 --- /dev/null +++ b/cnd.execution/src/org/netbeans/modules/cnd/execution/spi/NativeProcessCreator.java @@ -0,0 +1,69 @@ +/* + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. + * + * Copyright 2012 Oracle and/or its affiliates. All rights reserved. + * + * Oracle and Java are registered trademarks of Oracle and/or its affiliates. + * Other names may be trademarks of their respective owners. + * + * The contents of this file are subject to the terms of either the GNU + * General Public License Version 2 only ("GPL") or the Common + * Development and Distribution License("CDDL") (collectively, the + * "License"). You may not use this file except in compliance with the + * License. You can obtain a copy of the License at + * http://www.netbeans.org/cddl-gplv2.html + * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the + * specific language governing permissions and limitations under the + * License. When distributing the software, include this License Header + * Notice in each file and include the License file at + * nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the GPL Version 2 section of the License file that + * accompanied this code. If applicable, add the following below the + * License Header, with the fields enclosed by brackets [] replaced by + * your own identifying information: + * "Portions Copyrighted [year] [name of copyright owner]" + * + * If you wish your version of this file to be governed by only the CDDL + * or only the GPL Version 2, indicate your decision by adding + * "[Contributor] elects to include this software in this distribution + * under the [CDDL or GPL Version 2] license." If you do not indicate a + * single choice of license, a recipient has the option to distribute + * your version of this file under either the CDDL, the GPL Version 2 or + * to extend the choice of license to its licensees as provided above. + * However, if you add GPL Version 2 code and therefore, elected the GPL + * Version 2 license, then the option applies only if the new code is + * made subject to such option by the copyright holder. + * + * Contributor(s): + * + * Portions Copyrighted 2012 Sun Microsystems, Inc. + */ +package org.netbeans.modules.cnd.execution.spi; + +import org.netbeans.modules.cnd.execution.api.NativeExecutionException; +import org.netbeans.modules.cnd.execution.api.NativeProcessBuilder; +import org.openide.util.Lookup; + +/** + * An SPI interface for providing process creator implementation. + * + * @author akrasny + */ +public interface NativeProcessCreator extends Lookup.Provider { + + /** + * Takes parameters configured by a {@link NativeProcessBuilder} and starts + * a new process in accordance to that parameters. + * + * @param params parameters configured with a {@link NativeProcessBuilder}. + * Never {@code null}. + * + * @return a new started process implementation. + * + * @throws NativeExecutionException is thrown if process cannot be started. + */ + public NativeProcessImplementation createAndStart( + final NativeProcessParams params) throws NativeExecutionException; + +} diff --git a/cnd.execution/src/org/netbeans/modules/cnd/execution/spi/NativeProcessImplementation.java b/cnd.execution/src/org/netbeans/modules/cnd/execution/spi/NativeProcessImplementation.java new file mode 100644 --- /dev/null +++ b/cnd.execution/src/org/netbeans/modules/cnd/execution/spi/NativeProcessImplementation.java @@ -0,0 +1,114 @@ +/* + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. + * + * Copyright 2012 Oracle and/or its affiliates. All rights reserved. + * + * Oracle and Java are registered trademarks of Oracle and/or its affiliates. + * Other names may be trademarks of their respective owners. + * + * The contents of this file are subject to the terms of either the GNU + * General Public License Version 2 only ("GPL") or the Common + * Development and Distribution License("CDDL") (collectively, the + * "License"). You may not use this file except in compliance with the + * License. You can obtain a copy of the License at + * http://www.netbeans.org/cddl-gplv2.html + * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the + * specific language governing permissions and limitations under the + * License. When distributing the software, include this License Header + * Notice in each file and include the License file at + * nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the GPL Version 2 section of the License file that + * accompanied this code. If applicable, add the following below the + * License Header, with the fields enclosed by brackets [] replaced by + * your own identifying information: + * "Portions Copyrighted [year] [name of copyright owner]" + * + * If you wish your version of this file to be governed by only the CDDL + * or only the GPL Version 2, indicate your decision by adding + * "[Contributor] elects to include this software in this distribution + * under the [CDDL or GPL Version 2] license." If you do not indicate a + * single choice of license, a recipient has the option to distribute + * your version of this file under either the CDDL, the GPL Version 2 or + * to extend the choice of license to its licensees as provided above. + * However, if you add GPL Version 2 code and therefore, elected the GPL + * Version 2 license, then the option applies only if the new code is + * made subject to such option by the copyright holder. + * + * Contributor(s): + * + * Portions Copyrighted 2012 Sun Microsystems, Inc. + */ +package org.netbeans.modules.cnd.execution.spi; + +import java.io.InputStream; +import java.io.OutputStream; + +/** + * + * @author akrasny + */ +public interface NativeProcessImplementation { + + /** + * Returns a PID of the process. + * + * @return the PID of the process or -1 if real PID cannot be provided. + */ + public int getPID(); + + /** + * Returns the output stream of the process. + * + *Output to the stream should be piped into the input stream of the + * process.
+ * + * @return the output stream connected to the input of the process. + */ + public OutputStream getOutputStream(); + + /** + * Returns the input stream of the process. + * + *The stream should obtain data piped from the output stream of the + * process.
+ * + * @return the input stream connected to the output stream of the process. + */ + public InputStream getInputStream(); + + /** + * Returns the error stream of the process. + * + *The stream should obtain data piped from the error output stream of + * the process.
+ * + * @return the input stream connected to the error stream of the process. + */ + public InputStream getErrorStream(); + + /** + * Implementation should cause the current thread to wait, if necessary, + * until the process has terminated. + * + *This method should return immediately if the process has already + * terminated. If the process has not yet terminated, the calling thread + * should be blocked until the process exits.
+ * + * @return the exit value of the process. By convention, 0 indicates normal + * termination. + * @throws InterruptedException if the current thread is interrupted by + * another thread while it is waiting, then the wait is ended and an + * InterruptedException is thrown. + */ + public int waitResult() throws InterruptedException; + + /** + * Implementation-specific termination of the underlying system process. + * + *It is guaranteed that this method is called only once. Implementation + * should not (but may) wait for the actual termination before returning + * from the call.
+ */ + public void destroy(); +} diff --git a/cnd.execution/src/org/netbeans/modules/cnd/execution/spi/NativeProcessParams.java b/cnd.execution/src/org/netbeans/modules/cnd/execution/spi/NativeProcessParams.java new file mode 100644 --- /dev/null +++ b/cnd.execution/src/org/netbeans/modules/cnd/execution/spi/NativeProcessParams.java @@ -0,0 +1,197 @@ +/* + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. + * + * Copyright 2012 Oracle and/or its affiliates. All rights reserved. + * + * Oracle and Java are registered trademarks of Oracle and/or its affiliates. + * Other names may be trademarks of their respective owners. + * + * The contents of this file are subject to the terms of either the GNU + * General Public License Version 2 only ("GPL") or the Common + * Development and Distribution License("CDDL") (collectively, the + * "License"). You may not use this file except in compliance with the + * License. You can obtain a copy of the License at + * http://www.netbeans.org/cddl-gplv2.html + * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the + * specific language governing permissions and limitations under the + * License. When distributing the software, include this License Header + * Notice in each file and include the License file at + * nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the GPL Version 2 section of the License file that + * accompanied this code. If applicable, add the following below the + * License Header, with the fields enclosed by brackets [] replaced by + * your own identifying information: + * "Portions Copyrighted [year] [name of copyright owner]" + * + * If you wish your version of this file to be governed by only the CDDL + * or only the GPL Version 2, indicate your decision by adding + * "[Contributor] elects to include this software in this distribution + * under the [CDDL or GPL Version 2] license." If you do not indicate a + * single choice of license, a recipient has the option to distribute + * your version of this file under either the CDDL, the GPL Version 2 or + * to extend the choice of license to its licensees as provided above. + * However, if you add GPL Version 2 code and therefore, elected the GPL + * Version 2 license, then the option applies only if the new code is + * made subject to such option by the copyright holder. + * + * Contributor(s): + * + * Portions Copyrighted 2012 Sun Microsystems, Inc. + */ +package org.netbeans.modules.cnd.execution.spi; + +import java.util.Collections; +import java.util.List; +import java.util.Map; +import org.netbeans.modules.cnd.execution.access.NativeProcessParamsFactory; +import org.netbeans.modules.cnd.execution.api.Connection; +import org.netbeans.modules.cnd.execution.api.NativeProcessBuilder; +import org.netbeans.modules.cnd.execution.common.NativeProcess; +import org.openide.util.Lookup; + +/** + * Parameters constructed by a {@link NativeProcessBuilder} to be used for + * {@link NativeProcess} creation. + * + *This is an immutable object.
+ * + * @author akrasny + */ +public final class NativeProcessParams implements Lookup.Provider { + + private final Connection connection; + private final MapThere are two mutually exclusive attributes - a shell script and a + * list of a command with it's arguments. Only one of these attributes could + * be set.
+ * + * @return an immutable list of a command and it's arguments. + */ + public ListThere are two mutually exclusive attributes - a shell script and a + * list of a command with it's arguments. Only one of these attributes could + * be set.
+ * + * @return a shell script to start. + */ + public String getShellScript() { + return shellScript; + } + + /** + * A shell to be used to start a specified shell script (if any). + * + * @see #getShellScript() + * @return a path to the shell to be used to start a specified shell script. + */ + public String getShell() { + return shell; + } + + /** + * Returns an immutable map of all attributes associated with the current + * {@link Connection}. + * + * @return an immutable map of all attributes associated with the current + * {@link Connection}. + */ + public MapShould be registered in the global Lookup within a
+ * {@code ConnectionService/
{@link ConnectionManager} uses registered URIIdentifiers to compare URIs + * equality. As an example URIs {@code ssh://user:password@host} and {@code ssh://user@host} + * could denote the same connection end point.
+ * + *If no Identifier registered for a particular scheme, URI's equals() method + * is used.
+ * + * @author akrasny + */ +public interface URIIdentifier { + + /** + * Tests whether these URIs denote the same connection. + * + * @param uri1 the first URI to compare + * @param uri2 the second URI to compare + * @return true if these URIs are the same from SPI provider point of view. + */ + public boolean areIdentical(final URI uri1, final URI uri2); +} diff --git a/cnd.execution/src/org/netbeans/modules/cnd/execution/spi/UserInteraction.java b/cnd.execution/src/org/netbeans/modules/cnd/execution/spi/UserInteraction.java new file mode 100644 --- /dev/null +++ b/cnd.execution/src/org/netbeans/modules/cnd/execution/spi/UserInteraction.java @@ -0,0 +1,55 @@ +/* + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. + * + * Copyright 2012 Oracle and/or its affiliates. All rights reserved. + * + * Oracle and Java are registered trademarks of Oracle and/or its affiliates. + * Other names may be trademarks of their respective owners. + * + * The contents of this file are subject to the terms of either the GNU + * General Public License Version 2 only ("GPL") or the Common + * Development and Distribution License("CDDL") (collectively, the + * "License"). You may not use this file except in compliance with the + * License. You can obtain a copy of the License at + * http://www.netbeans.org/cddl-gplv2.html + * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the + * specific language governing permissions and limitations under the + * License. When distributing the software, include this License Header + * Notice in each file and include the License file at + * nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the GPL Version 2 section of the License file that + * accompanied this code. If applicable, add the following below the + * License Header, with the fields enclosed by brackets [] replaced by + * your own identifying information: + * "Portions Copyrighted [year] [name of copyright owner]" + * + * If you wish your version of this file to be governed by only the CDDL + * or only the GPL Version 2, indicate your decision by adding + * "[Contributor] elects to include this software in this distribution + * under the [CDDL or GPL Version 2] license." If you do not indicate a + * single choice of license, a recipient has the option to distribute + * your version of this file under either the CDDL, the GPL Version 2 or + * to extend the choice of license to its licensees as provided above. + * However, if you add GPL Version 2 code and therefore, elected the GPL + * Version 2 license, then the option applies only if the new code is + * made subject to such option by the copyright holder. + * + * Contributor(s): + * + * Portions Copyrighted 2012 Sun Microsystems, Inc. + */ +package org.netbeans.modules.cnd.execution.spi; + +import java.net.URI; + +/** + * + * @author Andrew + */ +public interface UserInteraction { + + public boolean promptYesNo(URI uri, String message); + + public void notify(URI uri, String message); +} diff --git a/cnd.execution/src/org/netbeans/modules/cnd/execution/spi/support/ConnectionInfo.java b/cnd.execution/src/org/netbeans/modules/cnd/execution/spi/support/ConnectionInfo.java new file mode 100644 --- /dev/null +++ b/cnd.execution/src/org/netbeans/modules/cnd/execution/spi/support/ConnectionInfo.java @@ -0,0 +1,84 @@ +/* + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. + * + * Copyright 2012 Oracle and/or its affiliates. All rights reserved. + * + * Oracle and Java are registered trademarks of Oracle and/or its affiliates. + * Other names may be trademarks of their respective owners. + * + * The contents of this file are subject to the terms of either the GNU + * General Public License Version 2 only ("GPL") or the Common + * Development and Distribution License("CDDL") (collectively, the + * "License"). You may not use this file except in compliance with the + * License. You can obtain a copy of the License at + * http://www.netbeans.org/cddl-gplv2.html + * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the + * specific language governing permissions and limitations under the + * License. When distributing the software, include this License Header + * Notice in each file and include the License file at + * nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the GPL Version 2 section of the License file that + * accompanied this code. If applicable, add the following below the + * License Header, with the fields enclosed by brackets [] replaced by + * your own identifying information: + * "Portions Copyrighted [year] [name of copyright owner]" + * + * If you wish your version of this file to be governed by only the CDDL + * or only the GPL Version 2, indicate your decision by adding + * "[Contributor] elects to include this software in this distribution + * under the [CDDL or GPL Version 2] license." If you do not indicate a + * single choice of license, a recipient has the option to distribute + * your version of this file under either the CDDL, the GPL Version 2 or + * to extend the choice of license to its licensees as provided above. + * However, if you add GPL Version 2 code and therefore, elected the GPL + * Version 2 license, then the option applies only if the new code is + * made subject to such option by the copyright holder. + * + * Contributor(s): + * + * Portions Copyrighted 2012 Sun Microsystems, Inc. + */ +package org.netbeans.modules.cnd.execution.spi.support; + +import java.util.Map; +import org.netbeans.modules.cnd.execution.api.Connection; +import org.netbeans.modules.cnd.execution.api.EnvironmentMap; +import org.netbeans.modules.cnd.execution.spi.ConnectionImplementation; +import org.netbeans.modules.cnd.execution.util.HostInfo; +import org.openide.util.Lookup; + +/** + * Connection info is just a map of String-String properties and an initial + * {@link EnvironmentMap} of the {@link Connection}. + * + *{@link ConnectionImplementation} SPI implementors use this interface to provide a + * map of connection-specific properties. For this implementations of {@link ConnectionInfoProvider} + * should be put into connection's {@link Lookup} (See {@link ConnectionImplementation}). + * Information from all SPI implementors is collected and merged altogether by + * the execution infrastructure before making a final association with the {@link Connection}.
+ * + *Note: {@link HostInfo} is constructed from the known subset of these + * properties. SPI implementor should make sure that expected properties are + * provided if they want HostInfo service to provide a meaningful + * information.
+ * + * @see HostInfo + */ +public interface ConnectionInfo { + + /** + * Returns an EnvironmentMap filled with variables discovered by the + * implementation. + * + * @return the populated EnvironmentMap. + */ + public MapAmong other usages, this information is used to construct a {@link HostInfo} + * object to provide an easy access to the most common host-specific + * attributes.
+ * + *Implementors of {@link ConnectionInfoProvider} could provide following + * properties that are used by the {@link HostInfo} class:
+ * + * + *+ * ------------+------------------------------------------------------ + * Name | Possible values (otherwise will be set to UNKNOWN) + * ------------+------------------------------------------------------ + * CPUFAMILY | SPARC, X86 + * BITNESS | 32, 64 + * OSFAMILY | SOLARIS, LINUX, WINDOWS, MACOSX + * OSBUILD | <any string> + * OSNAME | <any string> + * CPUNUM | <any positive integer> + *+ * + * @author akrasny + */ +public interface ConnectionInfoProvider { + + /** + * A method to be implemented by an SPI provider. + * + *
It is guaranteed that this method is invoked outside the EDT and not + * concurrently for the same connection.
+ * + *Implementor should not do any caching of the collected data. This + * method is called at least once during a connection establishment process, + * but could be called again if implicit refresh is requested.
+ * + *Note: gathering {@link ConnectionInfo} from the SPI implementors is a + * part of connection process and {@link Connection} is considered to be + * established (and publicly available) when only after all providers are + * done with this task.
+ * + * @return a {@link ConnectionInfo} discovered by an implementor. + */ + public ConnectionInfo getConnectionInfo(Connection connection) throws NativeExecutionException; +} diff --git a/cnd.execution/src/org/netbeans/modules/cnd/execution/spi/support/SignalSupport.java b/cnd.execution/src/org/netbeans/modules/cnd/execution/spi/support/SignalSupport.java new file mode 100644 --- /dev/null +++ b/cnd.execution/src/org/netbeans/modules/cnd/execution/spi/support/SignalSupport.java @@ -0,0 +1,114 @@ +/* + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. + * + * Copyright 2012 Oracle and/or its affiliates. All rights reserved. + * + * Oracle and Java are registered trademarks of Oracle and/or its affiliates. + * Other names may be trademarks of their respective owners. + * + * The contents of this file are subject to the terms of either the GNU + * General Public License Version 2 only ("GPL") or the Common + * Development and Distribution License("CDDL") (collectively, the + * "License"). You may not use this file except in compliance with the + * License. You can obtain a copy of the License at + * http://www.netbeans.org/cddl-gplv2.html + * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the + * specific language governing permissions and limitations under the + * License. When distributing the software, include this License Header + * Notice in each file and include the License file at + * nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the GPL Version 2 section of the License file that + * accompanied this code. If applicable, add the following below the + * License Header, with the fields enclosed by brackets [] replaced by + * your own identifying information: + * "Portions Copyrighted [year] [name of copyright owner]" + * + * If you wish your version of this file to be governed by only the CDDL + * or only the GPL Version 2, indicate your decision by adding + * "[Contributor] elects to include this software in this distribution + * under the [CDDL or GPL Version 2] license." If you do not indicate a + * single choice of license, a recipient has the option to distribute + * your version of this file under either the CDDL, the GPL Version 2 or + * to extend the choice of license to its licensees as provided above. + * However, if you add GPL Version 2 code and therefore, elected the GPL + * Version 2 license, then the option applies only if the new code is + * made subject to such option by the copyright holder. + * + * Contributor(s): + * + * Portions Copyrighted 2012 Sun Microsystems, Inc. + */ +package org.netbeans.modules.cnd.execution.spi.support; + +import org.netbeans.modules.cnd.execution.common.NativeProcess; +import org.netbeans.modules.cnd.execution.spi.ConnectionImplementation; +import org.netbeans.modules.cnd.execution.common.SignalUtils.Signal; +import org.openide.util.Lookup; + +/** + * + * An extension point for providing a signals support. + * + *Implementors of the {@link ConnectionImplementation} SPI could register their + * implementation of the + * {@link SignalSupportProvider} in the {@link Lookup} associated with the + * connection.
+ * + *By convention if implementation cannot perform a task, + * {@link UnsupportedOperationException} is thrown.
+ * + * @author akrasny + */ +public interface SignalSupport { + + /** + * A request to send a signal to a specific process. + * + * @param process {@link NativeProcess} to signal. + * @param signal the {@link Signal} to be send. + */ + public void signal(NativeProcess process, Signal signal); + + /** + * A request to send a signal to a group the process belongs to. + * + * @param process {@link NativeProcess} which group should receive a signal. + * @param signal the {@link Signal} to be send. + */ + public void signalGrp(NativeProcess process, Signal signal); + + /** + * A request to send a signal with an attached value to a specific process. + * + * @param process {@link NativeProcess} to signal. + * @param signal the {@link Signal} to be send. + * @param value the value to send together with the signal. + */ + public void sigqueue(NativeProcess process, Signal signal, int value); + + /** + * A request to send a signal to a specific process. + * + * @param pid a PID of a process to signal. + * @param signal the {@link Signal} to be send. + */ + public void signal(int pid, Signal signal); + + /** + * A request to send a signal to a group the process belongs to. + * + * @param pid the PID of a process which group should receive a signal. + * @param signal the {@link Signal} to be send. + */ + public void signalGrp(int pid, Signal signal); + + /** + * A request to send a signal with an attached value to a specific process. + * + * @param pid the PID of a process to signal. + * @param signal the {@link Signal} to be send. + * @param value the value to send together with the signal. + */ + public void sigqueue(int pid, Signal signal, int value); +} diff --git a/cnd.execution/src/org/netbeans/modules/cnd/execution/spi/support/SignalSupportProvider.java b/cnd.execution/src/org/netbeans/modules/cnd/execution/spi/support/SignalSupportProvider.java new file mode 100644 --- /dev/null +++ b/cnd.execution/src/org/netbeans/modules/cnd/execution/spi/support/SignalSupportProvider.java @@ -0,0 +1,67 @@ +/* + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. + * + * Copyright 2012 Oracle and/or its affiliates. All rights reserved. + * + * Oracle and Java are registered trademarks of Oracle and/or its affiliates. + * Other names may be trademarks of their respective owners. + * + * The contents of this file are subject to the terms of either the GNU + * General Public License Version 2 only ("GPL") or the Common + * Development and Distribution License("CDDL") (collectively, the + * "License"). You may not use this file except in compliance with the + * License. You can obtain a copy of the License at + * http://www.netbeans.org/cddl-gplv2.html + * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the + * specific language governing permissions and limitations under the + * License. When distributing the software, include this License Header + * Notice in each file and include the License file at + * nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the GPL Version 2 section of the License file that + * accompanied this code. If applicable, add the following below the + * License Header, with the fields enclosed by brackets [] replaced by + * your own identifying information: + * "Portions Copyrighted [year] [name of copyright owner]" + * + * If you wish your version of this file to be governed by only the CDDL + * or only the GPL Version 2, indicate your decision by adding + * "[Contributor] elects to include this software in this distribution + * under the [CDDL or GPL Version 2] license." If you do not indicate a + * single choice of license, a recipient has the option to distribute + * your version of this file under either the CDDL, the GPL Version 2 or + * to extend the choice of license to its licensees as provided above. + * However, if you add GPL Version 2 code and therefore, elected the GPL + * Version 2 license, then the option applies only if the new code is + * made subject to such option by the copyright holder. + * + * Contributor(s): + * + * Portions Copyrighted 2012 Sun Microsystems, Inc. + */ +package org.netbeans.modules.cnd.execution.spi.support; + +import org.netbeans.modules.cnd.execution.api.Connection; +import org.netbeans.modules.cnd.execution.spi.ConnectionImplementation; +import org.openide.util.Lookup; + +/** + * Provider of {@link SignalSupport} for a specific {@link Connection}. + * + *Implementors of the {@link ConnectionImplementation} SPI could register their + * implementation of the {@link SignalSupportProvider} in the {@link Lookup} + * associated with the connection.
+ * + * @author akrasny + */ +public interface SignalSupportProvider { + + /** + * Returns a {@link SignalSupport} implementation for a specific {@link Connection}. + * + * @param connection connection to get {@link SignalSupport} for. + * @return the {@link SignalSupport} implementation for the specified {@link Connection}. + * + */ + public SignalSupport getSignalSupport(Connection connection); +} diff --git a/cnd.execution/src/org/netbeans/modules/cnd/execution/util/Computable.java b/cnd.execution/src/org/netbeans/modules/cnd/execution/util/Computable.java new file mode 100644 --- /dev/null +++ b/cnd.execution/src/org/netbeans/modules/cnd/execution/util/Computable.java @@ -0,0 +1,69 @@ +/* + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. + * + * Copyright 2010 Oracle and/or its affiliates. All rights reserved. + * + * Oracle and Java are registered trademarks of Oracle and/or its affiliates. + * Other names may be trademarks of their respective owners. + * + * The contents of this file are subject to the terms of either the GNU + * General Public License Version 2 only ("GPL") or the Common + * Development and Distribution License("CDDL") (collectively, the + * "License"). You may not use this file except in compliance with the + * License. You can obtain a copy of the License at + * http://www.netbeans.org/cddl-gplv2.html + * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the + * specific language governing permissions and limitations under the + * License. When distributing the software, include this License Header + * Notice in each file and include the License file at + * nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this + * particular file as subject to the "Classpath" exception as provided + * by Oracle in the GPL Version 2 section of the License file that + * accompanied this code. If applicable, add the following below the + * License Header, with the fields enclosed by brackets [] replaced by + * your own identifying information: + * "Portions Copyrighted [year] [name of copyright owner]" + * + * If you wish your version of this file to be governed by only the CDDL + * or only the GPL Version 2, indicate your decision by adding + * "[Contributor] elects to include this software in this distribution + * under the [CDDL or GPL Version 2] license." If you do not indicate a + * single choice of license, a recipient has the option to distribute + * your version of this file under either the CDDL, the GPL Version 2 or + * to extend the choice of license to its licensees as provided above. + * However, if you add GPL Version 2 code and therefore, elected the GPL + * Version 2 license, then the option applies only if the new code is + * made subject to such option by the copyright holder. + * + * Contributor(s): + * + * Portions Copyrighted 2009 Sun Microsystems, Inc. + */ +package org.netbeans.modules.cnd.execution.util; + +import org.netbeans.modules.cnd.execution.api.NativeExecutionException; + +/** + * An interface for calculating a result based on a single parameter. + * + * This interface is most useful in conjuction with the {@link TasksCachedProcessor} + * class. + * + * @param the parameter type.
+ * @param This class gives an easy access to the most common host-specific
+ * attributes. Note: It is supposed that in most cases there is some host behind a
+ * {@link Connection}. Theoretically there could be connections where host info
+ * (entirely or partially) is not applicable. For such connections HostInfo
+ * attributes will be set to {@code "UNKNOWN"} value. Macros in the form {@code $NAME} and {@code ${NAME}} are
+ * supported. Any macro that is not in the dictionary is left in the string (in the
+ * {@code ${NAME}} form). Current implementation does a single pass of expansion: There is a notion of URIs equivalence. Equivalent URIs could verbally
+ * differ, but denote the same destination.
+ *
+ * the result of a string {@code "C=${B}"} expansion with a dictionary
+ * {@code ["A=VALUE", "B=$A"]} is {@code "C=${A}"}.
+ *
+ *
+ */
+ @Test
+ public void testGetConnection() throws Exception {
+ final URI uri1 = new URI("test://tester@computer:22");
+ final URI uri2 = new URI("test://tester:tester@computer:22");
+
+ Connection c1, c2;
+
+ c1 = ConnectionManager.getConnection(uri1);
+ assertNull("ConnectionManager must return NULL if no ACTIVE connection with equivalent URI exists", c1);
+
+ c2 = ConnectionManager.getConnection(uri2);
+ assertNull("ConnectionManager must return NULL if no ACTIVE connection with equivalent URI exists", c2);
+
+ try {
+ c1 = ConnectionManager.connect(uri1, null);
+ assertTrue("At this point connection should be in connected state", c1.isConnected());
+ assertNotNull("Returned connection is NEVER null", c1);
+ assertTrue("Returned connection is connected", c1.isConnected());
+
+ c2 = ConnectionManager.connect(uri2, null);
+ assertNotNull("Connection exists => returned connection should be not null", c2);
+ assertTrue("Returned connection is connected", c2.isConnected());
+
+ assertEquals("Now connections should be the same", c1, c2);
+
+ ConnectionManager.disconnect(c2);
+
+ assertFalse("connection must be disconnected", c1.isConnected());
+ assertFalse("connection must be disconnected", c2.isConnected());
+
+ } catch (Exception ex) {
+ assertTrue("Unexpected exception", false);
+ }
+
+// c2 = ConnectionManager.connect(uri2, null);
+// assertTrue("At this point connection should be in connected state", c2.isConnected());
+//
+// assertTrue("Once connection was established, there should be a single Connection object for all equivalent URIs", c1 == c2);
+// assertTrue("Once connection was established, there should be a single Connection object for all equivalent URIs", c1 == ConnectionManager.getConnection(uri1));
+// assertTrue("Once connection was established, there should be a single Connection object for all equivalent URIs", c1 == ConnectionManager.getConnection(uri2));
+//
+// ConnectionManager.disconnect(c1);
+//
+// assertFalse("At this point connection should be in disconnected state", c1.isConnected());
+// assertFalse("At this point connection should be in disconnected state", c2.isConnected());
+//
+// c2 = ConnectionManager.getConnection(uri2);
+// assertNotNull("ConnectionManager must always return not NULL connection", c2);
+//
+// assertTrue("Even when connection was disconnected - the same object (if still refferenced) should be returned", c1 == c2);
+// System.out.println(System.identityHashCode(c1));
+// System.out.println(System.identityHashCode(c2));
+//
+// c1 = null;
+// c2 = null;
+// connection1 = null;
+// System.gc();
+//
+// c2 = ConnectionManager.getConnection(uri2);
+// c2 = ConnectionManager.connect(uri2, null);
+//
+// System.out.println(System.identityHashCode(c2));
+// System.out.println("should be true: " + c2.isConnected());
+// c2 = null;
+// System.gc();
+// c2 = ConnectionManager.getConnection(uri2);
+// System.out.println("should be true: " + c2.isConnected());
+ }
+
+ /**
+ * Test of getConnection method, of class ConnectionManager.
+ */
+ @Test
+ public void testGetLocalConnection() throws Exception {
+ }
+// @Test
+// public void testGetConnection() throws Exception {
+// final URI uri = new URI("test://tester@computer:22");
+// final AtomicInteger established = new AtomicInteger(0);
+// final AtomicInteger closed = new AtomicInteger(0);
+// final AtomicInteger lost = new AtomicInteger(0);
+// final AtomicInteger other = new AtomicInteger(0);
+//
+// final ConnectionStateChangeListener listener = new ConnectionStateChangeListener() {
+//
+// @Override
+// public void connectionStateChanged(ConnectionStateChangeEvent ce) {
+// switch (ce.getState()) {
+// case CONNECTION_ESTABLISHED:
+// established.incrementAndGet();
+// break;
+// case CONNECTION_CLOSED:
+// closed.incrementAndGet();
+// break;
+// case CONNECTION_LOST:
+// lost.incrementAndGet();
+// break;
+// default:
+// other.incrementAndGet();
+// }
+// }
+// };
+//
+//
+//// ConnectionsRegistryAccessor.addConnectionListener(listener);
+//
+// JPanel panel = new JPanel(new BorderLayout());
+// JButton button = new JButton("Do it!");
+// button.addActionListener(new ActionListener() {
+//
+// @Override
+// public void actionPerformed(ActionEvent e) {
+// try {
+// Connection connection = ConnectionManager.getConnection(uri);
+// connection.connect(new AuthDataProvider() {
+//
+// @Override
+// public
+ There is new SPI for ProcessBuilder named
+ ProcessBuilderImplementation2 which now implements
+ Lookup.Provider to be extensible and provides
+ a separate Environment object represented by
+ the EnvironmentImplementation in the SPI.
+ The ProcessBuilder itself allows access to those
+ new features via getLookup() and
+ getEnvironment() methods and it now also
+ implements Lookup.Provider. The utility class
+ ProcessParameters wraps up the parameters passed
+ to the SPI for process creation. Instances of
+ Environment API are created via
+ EnvironmentFactory support class.
+
+ There are also new classes extending a Process
+ functionality named ProcessCharset,
+ ProcessId and ProcessSignal allowing
+ client to get the charset, to get ID and to send signal to
+ a process. This might not be always supported and the support
+ may be pre-checked.
+
org.openide.windows.OutputWriter. API provides common implementations too.
+ The support API/SPI
+
The SPI
The creation of the external process is supported by ExternalProcessBuilder + and ProcessBuilder to make things easier.
++ The process returned by default or custom builders may support additional + features. To do so the process must be a Lookup.Provider and put + the implementation of the feature to lookup. The possible extensions are + located in org.netbeans.api.extexecution.process + package. The client then use static methods on respective classes in order + to use the extended functionality. +
@@ -232,8 +248,8 @@
In order to do so it will implement
-
- ProcessBuilderImplementation and pass
+
+ ProcessBuilderImplementation2 and pass
ProcessBuilder to its clients. The API instances are created with
help of
@@ -510,9 +526,8 @@
-->
- No known platform dependencies. In future there could be need for native code
- in order to terminate the whole process tree created by execution of external
- process.
+ No known platform dependencies. The platform dependent way of process
+ termination is in a separate implementation module.
- * It will execute the program with an associated I/O window, with stop and
- * restart buttons. It will also obey various descriptor properties such as
- * whether or not to show a progress bar.
+ * It will execute the program with an associated I/O window, possibly with
+ * stop and restart buttons. It will also obey various descriptor properties
+ * such as whether or not to show a progress bar.
*
* All processes launched by this class are terminated on VM exit (if
* these are not finished or terminated earlier).
*
- * Note that once service is run for the first time, subsequents runs can be
+ * Note that once service is run for the first time, subsequent runs can be
* invoked by the user (rerun button) if it is allowed to do so
* ({@link ExecutionDescriptor#isControllable()}).
*
*
- * Sample usage - executing ls command:
+ * Sample usage (ls command):
*
+ * Even simpler usage but without displaying output (ls command):
+ *
+ * Passed processInput will be implicitly closed when the execution (invoked by
+ * {@link #run()}) is finished. The client should not use the reader passed
+ * as argument anymore or the reader should be designed thread safe.
+ *
+ * @param processCreator callable returning the process to wrap up
+ * @param outputProcessor processor processing lines of standard output;
+ * may be
+ * Passed inputWriter and errorWriter will be implicitly closed when the
+ * execution (invoked by {@link #run()}) is finished. The client either
+ * should not use the passed writers anymore or these should be designed
+ * to be thread safe.
+ *
+ * @param processCreator callable returning the process to wrap up
+ * @param outputWriter where to write standard output of the process. Once
+ * passed it either should not be used anymore or it should
+ * be designed to be thread safe. May be
* The output tabs are reused (if caller does not use the custom one,
- * see {@link ExecutionDescriptor#getInputOutput()}) - the tab to reuse
- * (if any) is selected by having the same name and same buttons
- * (control and option). If there is no output tab to reuse new one
- * is opened.
+ * see {@link ExecutionDescriptor#getInputOutput()} or if it is not being
+ * run without output tab, see {@link #newService(java.util.concurrent.Callable, org.netbeans.api.extexecution.input.LineProcessor, org.netbeans.api.extexecution.input.LineProcessor, java.io.Reader)})
+ * - the tab to reuse (if any) is selected by having the same name
+ * and same buttons (control and option). If there is no output tab to
+ * reuse new one is opened.
*
- * This method can be invoked multiple times returning the different and
- * unrelated {@link Future}s. On each call
+ * On each call
* Thread safety of this class depends on thread safety of
- * the {@link ProcessBuilderImplementation} the class is using. If it is thread
+ * the implementation class.
+ *
+ * If the {@link ProcessBuilderImplementation} is used and it is thread
* safe (if possible the implementation should be even stateless) this class
* is thread safe as well.
+ *
+ * If the {@link ProcessBuilderImplementation2} is used and it is (including
+ * {@link EnvironmentImplementation}) thread safe and does not have any mutable
+ * configuration accessible via {@link ProcessBuilderImplementation2#getLookup()}
+ * it is thread safe as well. Otherwise it is not thread safe.
+ *
+ * The synchronization mechanism use in this object is the {@link ProcessBuilderImplementation}
+ * or {@link ProcessBuilderImplementation2} object monitor.
*
* @author Petr Hejl
* @since 1.28
*/
-public final class ProcessBuilder implements Callable
+ * This method is semi-deprecated. If {@link #getEnvironment()} is not
+ *
@@ -232,7 +373,7 @@
*
* Since version 1.35 implementors of this method are advised to throw
* a {@link UserQuestionException} in case the execution cannot be
- * performed and requires additional user confirmation, or configuration.
+ * performed and requires additional user confirmation, or configuration.
* Callers of this method may check for this exception and handle it
* appropriately.
*
@@ -248,52 +389,168 @@
@NonNull
@Override
public Process call() throws IOException {
- String currentExecutable = null;
- String currentWorkingDirectory = null;
+ String currentExecutable;
+ String currentWorkingDirectory;
List
+ * If the {@link Process} implementation wants to support charsets it has to
+ * implement {@link Lookup.Provider} and there has to be instance of this class
+ * in the returned {@link Lookup}. The functionality itself is implemented in
+ * methods {@link #getInputCharset()} and {@link #getOutputCharset()}.
+ *
+ * @author Petr Hejl
+ * @since 1.37
+ */
+public abstract class ProcessCharset {
+
+ private static ProcessCharset find(Process process) {
+ if (process instanceof Lookup.Provider) {
+ Lookup.Provider p = (Lookup.Provider) process;
+ return p.getLookup().lookup(ProcessCharset.class);
+ }
+ return null;
+ }
+
+ /**
+ * Checks whether the getting of charsets of the {@link Process} is supported.
+ * If the return value is
+ * If the {@link Process} implementation wants to support the ID it has to
+ * implement {@link Lookup.Provider} and there has to be instance of this class
+ * in the returned {@link Lookup}. The functionality itself is implemented in
+ * method {@link #getId()}.
+ *
+ * @author Petr Hejl
+ * @since 1.37
+ */
+public abstract class ProcessId {
+
+ private static ProcessId find(Process process) {
+ if (process instanceof Lookup.Provider) {
+ Lookup.Provider p = (Lookup.Provider) process;
+ return p.getLookup().lookup(ProcessId.class);
+ }
+ return null;
+ }
+
+ /**
+ * Checks whether the getting of the ID of the {@link Process} is supported.
+ * If the return value is
+ * If the {@link Process} implementation wants to support the signal sending
+ * it has to implement {@link Lookup.Provider} and there has to be instance
+ * of this class in the returned {@link Lookup}. The functionality itself is
+ * implemented in methods {@link #signal(org.netbeans.api.extexecution.process.ProcessSignal.Signal)}
+ * and {@link #signalGroup(org.netbeans.api.extexecution.process.ProcessSignal.Signal)}.
+ *
+ * @author Petr Hejl
+ * @since 1.37
+ */
+public abstract class ProcessSignal {
+
+ private static ProcessSignal find(Process process) {
+ if (process instanceof Lookup.Provider) {
+ Lookup.Provider p = (Lookup.Provider) process;
+ return p.getLookup().lookup(ProcessSignal.class);
+ }
+ return null;
+ }
+
+ /**
+ * Checks whether the signal sending is supported for the {@link Process}.
+ * If the return value is
+ * The environment variables stored in parameters are acquired by call to
+ * {@link Environment#values()}. So if the implementation does not aim to be
+ * or can't thread safe it may check or use the {@link Environment}
+ * directly.
+ *
+ * @param parameters the instance describing the process parameters
+ * @return a process created with specified parameters
+ * @throws IOException if the process could not be created
+ */
+ @NonNull
+ Process createProcess(@NonNull ProcessParameters parameters) throws IOException;
+
+}
diff --git a/extexecution/src/org/netbeans/spi/extexecution/ProcessParameters.java b/extexecution/src/org/netbeans/spi/extexecution/ProcessParameters.java
new file mode 100644
--- /dev/null
+++ b/extexecution/src/org/netbeans/spi/extexecution/ProcessParameters.java
@@ -0,0 +1,142 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
+ * Copyright 2013 Oracle and/or its affiliates. All rights reserved.
+ *
+ * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
+ * Other names may be trademarks of their respective owners.
+ *
+ * The contents of this file are subject to the terms of either the GNU
+ * General Public License Version 2 only ("GPL") or the Common
+ * Development and Distribution License("CDDL") (collectively, the
+ * "License"). You may not use this file except in compliance with the
+ * License. You can obtain a copy of the License at
+ * http://www.netbeans.org/cddl-gplv2.html
+ * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
+ * specific language governing permissions and limitations under the
+ * License. When distributing the software, include this License Header
+ * Notice in each file and include the License file at
+ * nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the GPL Version 2 section of the License file that
+ * accompanied this code. If applicable, add the following below the
+ * License Header, with the fields enclosed by brackets [] replaced by
+ * your own identifying information:
+ * "Portions Copyrighted [year] [name of copyright owner]"
+ *
+ * If you wish your version of this file to be governed by only the CDDL
+ * or only the GPL Version 2, indicate your decision by adding
+ * "[Contributor] elects to include this software in this distribution
+ * under the [CDDL or GPL Version 2] license." If you do not indicate a
+ * single choice of license, a recipient has the option to distribute
+ * your version of this file under either the CDDL, the GPL Version 2 or
+ * to extend the choice of license to its licensees as provided above.
+ * However, if you add GPL Version 2 code and therefore, elected the GPL
+ * Version 2 license, then the option applies only if the new code is
+ * made subject to such option by the copyright holder.
+ *
+ * Contributor(s):
+ *
+ * Portions Copyrighted 2013 Sun Microsystems, Inc.
+ */
+package org.netbeans.spi.extexecution;
+
+import java.util.List;
+import java.util.Map;
+import org.netbeans.api.annotations.common.CheckForNull;
+import org.netbeans.api.annotations.common.NonNull;
+import org.netbeans.modules.extexecution.ProcessParametersAccessor;
+
+/**
+ * The parameters configured for process creation.
+ *
+ * @see ProcessBuilderImplementation2
+ * @author Petr Hejl
+ * @since 1.37
+ */
+public final class ProcessParameters {
+
+ private final String executable;
+
+ private final String workingDirectory;
+
+ private final Listnull.
+ *
+ * @param name the name of the variable
+ * @return the value of the variable or null
+ */
+ @CheckForNull
+ public String getVariable(@NonNull String name) {
+ Parameters.notNull("name", name);
+
+ return implementation.getVariable(name);
+ }
+
+ /**
+ * Appends a path to a path-like variable. The proper path separator is used
+ * to separate the new value.
+ *
+ * @param name the name of the variable such as for example
+ * PATH or LD_LIBRARY_PATH
+ * @param value the value (path to append)
+ */
+ public void appendPath(@NonNull String name, @NonNull String value) {
+ Parameters.notNull("name", name);
+ Parameters.notNull("value", value);
+
+ implementation.appendPath(name, value);
+ }
+
+ /**
+ * Prepends a path to a path-like variable. The proper path separator is used
+ * to separate the new value.
+ *
+ * @param name the name of the variable such as for example
+ * PATH or LD_LIBRARY_PATH
+ * @param value the value (path to prepend)
+ */
+ public void prependPath(@NonNull String name, @NonNull String value) {
+ Parameters.notNull("name", name);
+ Parameters.notNull("value", value);
+
+ implementation.prependPath(name, value);
+ }
+
+ /**
+ * Sets a value for a variable with the given name.
+ *
+ * @param name the name of the variable
+ * @param value the value
+ */
+ public void setVariable(@NonNull String name, @NonNull String value) {
+ Parameters.notNull("name", name);
+ Parameters.notNull("value", value);
+
+ implementation.setVariable(name, value);
+ }
+
+ /**
+ * Removes a variable with the given name. The subsequent call to
+ * {@link #getVariable(java.lang.String)} with the same argument will return
+ * null.
+ *
+ * @param name the name of the variable
+ */
+ public void removeVariable(@NonNull String name) {
+ Parameters.notNull("name", name);
+
+ implementation.removeVariable(name);
+ }
+
+ /**
+ * Returns all variable names and associated values as a {@link Map}.
+ * Changes to the map are not propagated back to the {@link Environment}.
+ *
+ * @return all variable names and associated values
+ */
+ @NonNull
+ public Map
* ExecutionDescriptor descriptor = new ExecutionDescriptor()
* .frontWindow(true).controllable(true);
@@ -114,6 +119,14 @@
* ExecutionService service = ExecutionService.newService(processBuilder, descriptor, "ls command");
* Future<Integer> task = service.run();
*
+ *
+ * ExternalProcessBuilder processBuilder = new ExternalProcessBuilder("ls");
+ *
+ * ExecutionService service = ExecutionService.newService(processBuilder, null, null);
+ * Future<Integer> task = service.run();
+ *
* processCreator and will manage them. The service
+ * may not be run more than once otherwise {@link IllegalStateException}
+ * is thrown on {@link #run()}. No UI will be displayed.
+ * null
+ * @param errorProcessor processor processing lines of standard error
+ * output; may be null
+ * @param processorInput reader providing input for standard input of
+ * the created process. Once passed it either should not be
+ * used anymore or it should be designed to be thread safe.
+ * May be null.
+ * @return new execution service
+ * @since 1.37
+ */
+ @NonNull
+ public static ExecutionService newService(@NonNull Callable processCreator,
+ @NullAllowed final LineProcessor outputProcessor, @NullAllowed final LineProcessor errorProcessor,
+ @NullAllowed final Reader processorInput) {
+ ExecutionDescriptor descriptor = new ExecutionDescriptor()
+ .inputOutput(InputOutput.NULL);
+
+ if (outputProcessor != null) {
+ descriptor = descriptor.outProcessorFactory(new InputProcessorFactory() {
+ @Override
+ public InputProcessor newInputProcessor(InputProcessor defaultProcessor) {
+ return InputProcessors.bridge(outputProcessor);
+ }
+ });
+ }
+ if (errorProcessor != null) {
+ descriptor = descriptor.errProcessorFactory(new InputProcessorFactory() {
+ @Override
+ public InputProcessor newInputProcessor(InputProcessor defaultProcessor) {
+ return InputProcessors.bridge(errorProcessor);
+ }
+ });
+ }
+
+ return new ExecutionService(processCreator, null, descriptor, processorInput, false);
+ }
+
+ /**
+ * Creates new execution service. Service will wrap up the processes
+ * created by processCreator and will manage them. The service
+ * may not be run more than once otherwise {@link IllegalStateException}
+ * is thrown on {@link #run()}. No UI will be displayed.
+ * null.
+ * @param errorWriter where to write standard error output of the process.
+ * Once passed it either should not be used anymore or it should
+ * be designed to be thread safe. May be null.
+ * @return new execution service
+ * @since 1.37
+ */
+ public static ExecutionService newService(@NonNull Callable processCreator,
+ @NullAllowed final Writer outputWriter, @NullAllowed final Writer errorWriter) {
+ ExecutionDescriptor descriptor = new ExecutionDescriptor()
+ .inputOutput(InputOutput.NULL);
+
+ if (outputWriter != null) {
+ descriptor = descriptor.outProcessorFactory(new InputProcessorFactory() {
+ @Override
+ public InputProcessor newInputProcessor(InputProcessor defaultProcessor) {
+ return InputProcessors.copying(outputWriter);
+ }
+ });
+ }
+ if (errorWriter != null) {
+ descriptor = descriptor.errProcessorFactory(new InputProcessorFactory() {
+ @Override
+ public InputProcessor newInputProcessor(InputProcessor defaultProcessor) {
+ return InputProcessors.copying(errorWriter);
+ }
+ });
+ }
+
+ return new ExecutionService(processCreator, null, descriptor, null, false);
}
/**
* Runs the process described by this service. The call does not block
* and the task is represented by the returned value. Integer returned
* as a result of the {@link Future} is exit code of the process.
+ * The ability to call this method multiple times depends on a way
+ * in which the service has been created. Only service created by
+ * {@link #newService(java.util.concurrent.Callable, org.netbeans.api.extexecution.ExecutionDescriptor, java.lang.String)}
+ * may be run more than once.
* Callable<Process>
+ * If the service has been created by {@link #newService(java.util.concurrent.Callable, org.netbeans.api.extexecution.input.LineProcessor, org.netbeans.api.extexecution.input.LineProcessor, java.io.Reader)}
+ * this method may be called only once. Subsequent calls will cause an
+ * {@link IllegalStateException} to be thrown.
+ * If the service has been created by {@link #newService(java.util.concurrent.Callable, org.netbeans.api.extexecution.ExecutionDescriptor, java.lang.String)}
+ * this method can be invoked multiple times returning the different and
+ * unrelated {@link Future}s.
+ * Callable<Process>
* passed to {@link #newService(java.util.concurrent.Callable, org.netbeans.api.extexecution.ExecutionDescriptor, java.lang.String)}
* is invoked in order to create the process. If the process creation fails
* (throwing an exception) returned Future will throw
@@ -213,6 +356,10 @@
}
private Futurepb using the given level.
*
@@ -331,18 +345,7 @@
// Find PATH environment variable - on Windows it can be some other
// case and we should use whatever it has.
- String pathName = "PATH"; // NOI18N
-
- if (Utilities.isWindows()) {
- pathName = "Path"; // NOI18N
-
- for (String key : ret.keySet()) {
- if ("PATH".equals(key.toUpperCase(Locale.ENGLISH))) { // NOI18N
- pathName = key;
- break;
- }
- }
- }
+ String pathName = getPathName(original);
// TODO use StringBuilder
String currentPath = ret.get(pathName);
@@ -362,6 +365,7 @@
return ret;
}
+
// package level for unit testing
ListPATH possibly configured by {@link #setPaths(java.util.List)}.
*
* @param envVariables the environment variables for the process
+ * @deprecated use {@link Environment#setVariable(java.lang.String, java.lang.String)}
+ * on object received by {@link #getEnvironment()} call
*/
public void setEnvironmentVariables(@NonNull MapPATH environment
- * variable for the process.
+ * variable for the process. The paths are prepended to the PATH variable
+ * one by one as specified in the list so in fact the last path in
+ * the list will be the first one in the PATH variable.
+ * null this call adds paths one by one by call to
+ * {@link Environment#prependPath(java.lang.String, java.lang.String)}
+ * on returned object.
*
* @param paths the additional paths to be included in PATH
* environment variable
+ * @deprecated use {@link Environment#prependPath(java.lang.String, java.lang.String)}
+ * on object received by {@link #getEnvironment()} call, with
+ * the first argument being PATH
*/
public void setPaths(@NonNull Listfalse methods
+ * {@link #getInputCharset(java.lang.Process)} and {@link #getOutputCharset(java.lang.Process)}
+ * will return null for sure.
+ *
+ * @param process the process to check
+ * @return true if process charsets can be received false
+ * otherwise
+ */
+ public static boolean isSupported(@NonNull Process process) {
+ Parameters.notNull("process", process);
+
+ return find(process) != null;
+ }
+
+ /**
+ * Returns the input charset of the process if supported. In case it is not
+ * supported or the process can't determine the charset null is
+ * returned.
+ *
+ * @param process the process
+ * @return the input charset of the process or null
+ */
+ @CheckForNull
+ public static Charset getInputCharset(@NonNull Process process) {
+ Parameters.notNull("process", process);
+
+ ProcessCharset processCharset = find(process);
+ if (processCharset != null) {
+ return processCharset.getInputCharset();
+ }
+ return null;
+ }
+
+ /**
+ * Returns the output charset of the process if supported. In case it is not
+ * supported or the process can't determine the charset null is
+ * returned.
+ *
+ * @param process the process
+ * @return the output charset of the process or null
+ */
+ @CheckForNull
+ public static Charset getOutputCharset(@NonNull Process process) {
+ Parameters.notNull("process", process);
+
+ ProcessCharset processCharset = find(process);
+ if (processCharset != null) {
+ return processCharset.getOutputCharset();
+ }
+ return null;
+ }
+
+ /**
+ * Returns the error output charset of the process if supported. In case it
+ * is not supported or the process can't determine the charset null
+ * is returned.
+ *
+ * @param process the process
+ * @return the error output charset of the process or null
+ */
+ @CheckForNull
+ public static Charset getErrorCharset(@NonNull Process process) {
+ Parameters.notNull("process", process);
+
+ ProcessCharset processCharset = find(process);
+ if (processCharset != null) {
+ return processCharset.getErrorCharset();
+ }
+ return null;
+ }
+
+ /**
+ * Returns the input charset of a process or null.
+ *
+ * @return input charset of a process or null
+ */
+ @CheckForNull
+ protected abstract Charset getInputCharset();
+
+ /**
+ * Returns the output charset of a process or null.
+ *
+ * @return output charset of a process or null
+ */
+ @CheckForNull
+ protected abstract Charset getOutputCharset();
+
+ /**
+ * Returns the error output charset of a process or null.
+ *
+ * @return error output charset of a process or null
+ */
+ @CheckForNull
+ protected abstract Charset getErrorCharset();
+}
diff --git a/extexecution/src/org/netbeans/api/extexecution/process/ProcessId.java b/extexecution/src/org/netbeans/api/extexecution/process/ProcessId.java
new file mode 100644
--- /dev/null
+++ b/extexecution/src/org/netbeans/api/extexecution/process/ProcessId.java
@@ -0,0 +1,111 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
+ * Copyright 2012 Oracle and/or its affiliates. All rights reserved.
+ *
+ * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
+ * Other names may be trademarks of their respective owners.
+ *
+ * The contents of this file are subject to the terms of either the GNU
+ * General Public License Version 2 only ("GPL") or the Common
+ * Development and Distribution License("CDDL") (collectively, the
+ * "License"). You may not use this file except in compliance with the
+ * License. You can obtain a copy of the License at
+ * http://www.netbeans.org/cddl-gplv2.html
+ * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
+ * specific language governing permissions and limitations under the
+ * License. When distributing the software, include this License Header
+ * Notice in each file and include the License file at
+ * nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the GPL Version 2 section of the License file that
+ * accompanied this code. If applicable, add the following below the
+ * License Header, with the fields enclosed by brackets [] replaced by
+ * your own identifying information:
+ * "Portions Copyrighted [year] [name of copyright owner]"
+ *
+ * If you wish your version of this file to be governed by only the CDDL
+ * or only the GPL Version 2, indicate your decision by adding
+ * "[Contributor] elects to include this software in this distribution
+ * under the [CDDL or GPL Version 2] license." If you do not indicate a
+ * single choice of license, a recipient has the option to distribute
+ * your version of this file under either the CDDL, the GPL Version 2 or
+ * to extend the choice of license to its licensees as provided above.
+ * However, if you add GPL Version 2 code and therefore, elected the GPL
+ * Version 2 license, then the option applies only if the new code is
+ * made subject to such option by the copyright holder.
+ *
+ * Contributor(s):
+ *
+ * Portions Copyrighted 2012 Sun Microsystems, Inc.
+ */
+package org.netbeans.api.extexecution.process;
+
+import org.netbeans.api.annotations.common.CheckForNull;
+import org.netbeans.api.annotations.common.NonNull;
+import org.openide.util.Lookup;
+import org.openide.util.Parameters;
+
+/**
+ * This class allows client to request ID of the {@link Process}. Though
+ * the process ID might not be always supported.
+ * false the {@link #getId(java.lang.Process)}
+ * will return null for sure.
+ *
+ * @param process the process to check
+ * @return true if the ID can be received false
+ * otherwise
+ */
+ public static boolean isSupported(@NonNull Process process) {
+ Parameters.notNull("process", process);
+
+ return find(process) != null;
+ }
+
+ /**
+ * Returns the ID of the process if supported. In case it is not supported
+ * or the process can't determine its ID null is returned.
+ *
+ * @param process the process
+ * @return the process ID or null
+ */
+ @CheckForNull
+ public static Integer getId(@NonNull Process process) {
+ Parameters.notNull("process", process);
+
+ ProcessId processId = find(process);
+ if (processId != null) {
+ return processId.getId();
+ }
+ return null;
+ }
+
+ /**
+ * Returns the ID of a process or null.
+ *
+ * @return ID of a process or null
+ */
+ @CheckForNull
+ protected abstract Integer getId();
+}
diff --git a/extexecution/src/org/netbeans/api/extexecution/process/ProcessSignal.java b/extexecution/src/org/netbeans/api/extexecution/process/ProcessSignal.java
new file mode 100644
--- /dev/null
+++ b/extexecution/src/org/netbeans/api/extexecution/process/ProcessSignal.java
@@ -0,0 +1,181 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
+ * Copyright 2012 Oracle and/or its affiliates. All rights reserved.
+ *
+ * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
+ * Other names may be trademarks of their respective owners.
+ *
+ * The contents of this file are subject to the terms of either the GNU
+ * General Public License Version 2 only ("GPL") or the Common
+ * Development and Distribution License("CDDL") (collectively, the
+ * "License"). You may not use this file except in compliance with the
+ * License. You can obtain a copy of the License at
+ * http://www.netbeans.org/cddl-gplv2.html
+ * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
+ * specific language governing permissions and limitations under the
+ * License. When distributing the software, include this License Header
+ * Notice in each file and include the License file at
+ * nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the GPL Version 2 section of the License file that
+ * accompanied this code. If applicable, add the following below the
+ * License Header, with the fields enclosed by brackets [] replaced by
+ * your own identifying information:
+ * "Portions Copyrighted [year] [name of copyright owner]"
+ *
+ * If you wish your version of this file to be governed by only the CDDL
+ * or only the GPL Version 2, indicate your decision by adding
+ * "[Contributor] elects to include this software in this distribution
+ * under the [CDDL or GPL Version 2] license." If you do not indicate a
+ * single choice of license, a recipient has the option to distribute
+ * your version of this file under either the CDDL, the GPL Version 2 or
+ * to extend the choice of license to its licensees as provided above.
+ * However, if you add GPL Version 2 code and therefore, elected the GPL
+ * Version 2 license, then the option applies only if the new code is
+ * made subject to such option by the copyright holder.
+ *
+ * Contributor(s):
+ *
+ * Portions Copyrighted 2012 Sun Microsystems, Inc.
+ */
+package org.netbeans.api.extexecution.process;
+
+import java.io.IOException;
+import org.netbeans.api.annotations.common.NonNull;
+import org.openide.util.Lookup;
+import org.openide.util.Parameters;
+
+/**
+ * This class allows client send a signal to the {@link Process} or to whole
+ * its group. Though signal sending might not be always supported.
+ * false the signal operations are
+ * effectively noops.
+ *
+ * @param process the process to check
+ * @return true if the signals can be send false
+ * otherwise
+ */
+ public static boolean isSupported(@NonNull Process process) {
+ Parameters.notNull("process", process);
+
+ return find(process) != null;
+ }
+
+ /**
+ * Sends a signal to the process. If the signal sending is not supported
+ * this is effectively noop.
+ *
+ * @param process the process where to send signal
+ * @param signal the signal to send
+ * @throws IOException if problem with signal sending occurs
+ */
+ public static void signal(@NonNull Process process, @NonNull Signal signal) throws IOException {
+ Parameters.notNull("process", process);
+ Parameters.notNull("signal", signal);
+
+ ProcessSignal processSignal = find(process);
+ if (processSignal != null) {
+ processSignal.signal(signal);
+ }
+ }
+
+ /**
+ * Sends a signal to the group the process belongs to. If the signal sending
+ * is not supported this is effectively noop.
+ *
+ * @param process the process marking the group where to send signal
+ * @param signal the signal to send
+ * @throws IOException if problem with signal sending occurs
+ */
+ public static void signalGroup(@NonNull Process process, @NonNull Signal signal) throws IOException {
+ Parameters.notNull("process", process);
+ Parameters.notNull("signal", signal);
+
+ ProcessSignal processSignal = find(process);
+ if (processSignal != null) {
+ processSignal.signalGroup(signal);
+ }
+ }
+
+ /**
+ * Sends a given signal to the process.
+ *
+ * @param signal the signal to send
+ * @throws IOException if problem with signal sending occurs
+ */
+ protected abstract void signal(@NonNull Signal signal) throws IOException;
+
+ /**
+ * Sends a given signal to the group the process belongs to.
+ *
+ * @param signal the signal to send
+ * @throws IOException if problem with signal sending occurs
+ */
+ protected abstract void signalGroup(@NonNull Signal signal) throws IOException;
+
+ public enum Signal {
+
+ NULL,
+ SIGHUP,
+ SIGINT,
+ SIGQUIT,
+ SIGILL,
+ SIGTRAP,
+ SIGABRT,
+ SIGEMT,
+ SIGFPE,
+ SIGKILL,
+ SIGBUS,
+ SIGSEGV,
+ SIGSYS,
+ SIGPIPE,
+ SIGALRM,
+ SIGTERM,
+ SIGUSR1,
+ SIGUSR2,
+ SIGCHLD,
+ SIGPWR,
+ SIGWINCH,
+ SIGURG,
+ SIGPOLL,
+ SIGSTOP,
+ SIGTSTP,
+ SIGCONT,
+ SIGTTIN,
+ SIGTTOU,
+ SIGVTALRM,
+ SIGPROF,
+ SIGXCPU,
+ SIGWAITING,
+ SIGLWP,
+ SIGFREEZE,
+ SIGTHAW,
+ SIGCANCEL,
+ SIGLOST,
+ SIGXRES,
+ SIGJVM1;
+ }
+}
diff --git a/extexecution/src/org/netbeans/api/extexecution/process/package-info.java b/extexecution/src/org/netbeans/api/extexecution/process/package-info.java
new file mode 100644
--- /dev/null
+++ b/extexecution/src/org/netbeans/api/extexecution/process/package-info.java
@@ -0,0 +1,50 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
+ * Copyright 1997-2010 Oracle and/or its affiliates. All rights reserved.
+ *
+ * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
+ * Other names may be trademarks of their respective owners.
+ *
+ * The contents of this file are subject to the terms of either the GNU
+ * General Public License Version 2 only ("GPL") or the Common
+ * Development and Distribution License("CDDL") (collectively, the
+ * "License"). You may not use this file except in compliance with the
+ * License. You can obtain a copy of the License at
+ * http://www.netbeans.org/cddl-gplv2.html
+ * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
+ * specific language governing permissions and limitations under the
+ * License. When distributing the software, include this License Header
+ * Notice in each file and include the License file at
+ * nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the GPL Version 2 section of the License file that
+ * accompanied this code. If applicable, add the following below the
+ * License Header, with the fields enclosed by brackets [] replaced by
+ * your own identifying information:
+ * "Portions Copyrighted [year] [name of copyright owner]"
+ *
+ * Contributor(s):
+ *
+ * The Original Software is NetBeans. The Initial Developer of the Original
+ * Software is Sun Microsystems, Inc. Portions Copyright 1997-2007 Sun
+ * Microsystems, Inc. All Rights Reserved.
+ *
+ * If you wish your version of this file to be governed by only the CDDL
+ * or only the GPL Version 2, indicate your decision by adding
+ * "[Contributor] elects to include this software in this distribution
+ * under the [CDDL or GPL Version 2] license." If you do not indicate a
+ * single choice of license, a recipient has the option to distribute
+ * your version of this file under either the CDDL, the GPL Version 2 or
+ * to extend the choice of license to its licensees as provided above.
+ * However, if you add GPL Version 2 code and therefore, elected the GPL
+ * Version 2 license, then the option applies only if the new code is
+ * made subject to such option by the copyright holder.
+ */
+
+/**
+ * The API supporting enhanced functionality for
+ * a {@link java.lang.Process}.
+ */
+package org.netbeans.api.extexecution.process;
+
diff --git a/extexecution/src/org/netbeans/modules/extexecution/EnvironmentAccessor.java b/extexecution/src/org/netbeans/modules/extexecution/EnvironmentAccessor.java
new file mode 100644
--- /dev/null
+++ b/extexecution/src/org/netbeans/modules/extexecution/EnvironmentAccessor.java
@@ -0,0 +1,81 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
+ * Copyright 2012 Oracle and/or its affiliates. All rights reserved.
+ *
+ * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
+ * Other names may be trademarks of their respective owners.
+ *
+ * The contents of this file are subject to the terms of either the GNU
+ * General Public License Version 2 only ("GPL") or the Common
+ * Development and Distribution License("CDDL") (collectively, the
+ * "License"). You may not use this file except in compliance with the
+ * License. You can obtain a copy of the License at
+ * http://www.netbeans.org/cddl-gplv2.html
+ * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
+ * specific language governing permissions and limitations under the
+ * License. When distributing the software, include this License Header
+ * Notice in each file and include the License file at
+ * nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the GPL Version 2 section of the License file that
+ * accompanied this code. If applicable, add the following below the
+ * License Header, with the fields enclosed by brackets [] replaced by
+ * your own identifying information:
+ * "Portions Copyrighted [year] [name of copyright owner]"
+ *
+ * If you wish your version of this file to be governed by only the CDDL
+ * or only the GPL Version 2, indicate your decision by adding
+ * "[Contributor] elects to include this software in this distribution
+ * under the [CDDL or GPL Version 2] license." If you do not indicate a
+ * single choice of license, a recipient has the option to distribute
+ * your version of this file under either the CDDL, the GPL Version 2 or
+ * to extend the choice of license to its licensees as provided above.
+ * However, if you add GPL Version 2 code and therefore, elected the GPL
+ * Version 2 license, then the option applies only if the new code is
+ * made subject to such option by the copyright holder.
+ *
+ * Contributor(s):
+ *
+ * Portions Copyrighted 2012 Sun Microsystems, Inc.
+ */
+package org.netbeans.modules.extexecution;
+
+import org.netbeans.api.extexecution.Environment;
+import org.netbeans.spi.extexecution.EnvironmentImplementation;
+
+/**
+ *
+ * @author Petr Hejl
+ */
+public abstract class EnvironmentAccessor {
+
+ private static volatile EnvironmentAccessor DEFAULT;
+
+ public static EnvironmentAccessor getDefault() {
+ EnvironmentAccessor a = DEFAULT;
+ if (a != null) {
+ return a;
+ }
+
+ // invokes static initializer of Environment.class
+ // that will assign value to the DEFAULT field above
+ Class c = Environment.class;
+ try {
+ Class.forName(c.getName(), true, c.getClassLoader());
+ } catch (ClassNotFoundException ex) {
+ assert false : ex;
+ }
+ return DEFAULT;
+ }
+
+ public static void setDefault(EnvironmentAccessor accessor) {
+ if (DEFAULT != null) {
+ throw new IllegalStateException();
+ }
+
+ DEFAULT = accessor;
+ }
+
+ public abstract Environment createEnvironment(EnvironmentImplementation impl);
+}
diff --git a/extexecution/src/org/netbeans/modules/extexecution/ProcessBuilderAccessor.java b/extexecution/src/org/netbeans/modules/extexecution/ProcessBuilderAccessor.java
--- a/extexecution/src/org/netbeans/modules/extexecution/ProcessBuilderAccessor.java
+++ b/extexecution/src/org/netbeans/modules/extexecution/ProcessBuilderAccessor.java
@@ -42,6 +42,7 @@
package org.netbeans.modules.extexecution;
import org.netbeans.spi.extexecution.ProcessBuilderImplementation;
+import org.netbeans.spi.extexecution.ProcessBuilderImplementation2;
/**
*
@@ -78,4 +79,7 @@
public abstract org.netbeans.api.extexecution.ProcessBuilder createProcessBuilder(
ProcessBuilderImplementation impl, String description);
+
+ public abstract org.netbeans.api.extexecution.ProcessBuilder createProcessBuilder(
+ ProcessBuilderImplementation2 impl, String description);
}
diff --git a/extexecution/src/org/netbeans/modules/extexecution/ProcessParametersAccessor.java b/extexecution/src/org/netbeans/modules/extexecution/ProcessParametersAccessor.java
new file mode 100644
--- /dev/null
+++ b/extexecution/src/org/netbeans/modules/extexecution/ProcessParametersAccessor.java
@@ -0,0 +1,84 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
+ * Copyright 2012 Oracle and/or its affiliates. All rights reserved.
+ *
+ * Oracle and Java are registered trademarks of Oracle and/or its affiliates.
+ * Other names may be trademarks of their respective owners.
+ *
+ * The contents of this file are subject to the terms of either the GNU
+ * General Public License Version 2 only ("GPL") or the Common
+ * Development and Distribution License("CDDL") (collectively, the
+ * "License"). You may not use this file except in compliance with the
+ * License. You can obtain a copy of the License at
+ * http://www.netbeans.org/cddl-gplv2.html
+ * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
+ * specific language governing permissions and limitations under the
+ * License. When distributing the software, include this License Header
+ * Notice in each file and include the License file at
+ * nbbuild/licenses/CDDL-GPL-2-CP. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the GPL Version 2 section of the License file that
+ * accompanied this code. If applicable, add the following below the
+ * License Header, with the fields enclosed by brackets [] replaced by
+ * your own identifying information:
+ * "Portions Copyrighted [year] [name of copyright owner]"
+ *
+ * If you wish your version of this file to be governed by only the CDDL
+ * or only the GPL Version 2, indicate your decision by adding
+ * "[Contributor] elects to include this software in this distribution
+ * under the [CDDL or GPL Version 2] license." If you do not indicate a
+ * single choice of license, a recipient has the option to distribute
+ * your version of this file under either the CDDL, the GPL Version 2 or
+ * to extend the choice of license to its licensees as provided above.
+ * However, if you add GPL Version 2 code and therefore, elected the GPL
+ * Version 2 license, then the option applies only if the new code is
+ * made subject to such option by the copyright holder.
+ *
+ * Contributor(s):
+ *
+ * Portions Copyrighted 2012 Sun Microsystems, Inc.
+ */
+package org.netbeans.modules.extexecution;
+
+import java.util.List;
+import java.util.Map;
+import org.netbeans.spi.extexecution.ProcessParameters;
+
+/**
+ *
+ * @author Petr Hejl
+ */
+public abstract class ProcessParametersAccessor {
+
+ private static volatile ProcessParametersAccessor DEFAULT;
+
+ public static ProcessParametersAccessor getDefault() {
+ ProcessParametersAccessor a = DEFAULT;
+ if (a != null) {
+ return a;
+ }
+
+ // invokes static initializer of ProcessParameters.class
+ // that will assign value to the DEFAULT field above
+ Class c = ProcessParameters.class;
+ try {
+ Class.forName(c.getName(), true, c.getClassLoader());
+ } catch (ClassNotFoundException ex) {
+ assert false : ex;
+ }
+ return DEFAULT;
+ }
+
+ public static void setDefault(ProcessParametersAccessor accessor) {
+ if (DEFAULT != null) {
+ throw new IllegalStateException();
+ }
+
+ DEFAULT = accessor;
+ }
+
+ public abstract ProcessParameters createProcessParameters(String executable,
+ String workingDirectory, Listnull.
+ *
+ * @param name the name of the variable
+ * @return the value of the variable or null
+ */
+ @CheckForNull
+ String getVariable(@NonNull String name);
+
+ /**
+ * Appends a path to a path-like variable. The proper path separator should
+ * be used to separate the new value.
+ *
+ * @param name the name of the variable such as for example
+ * PATH or LD_LIBRARY_PATH
+ * @param value the value (path to append)
+ */
+ void appendPath(@NonNull String name, @NonNull String value);
+
+ /**
+ * Prepends a path to a path-like variable. The proper path separator should
+ * be used to separate the new value.
+ *
+ * @param name the name of the variable such as for example
+ * PATH or LD_LIBRARY_PATH
+ * @param value the value (path to prepend)
+ */
+ void prependPath(@NonNull String name, @NonNull String value);
+
+ /**
+ * Sets a value for a variable with the given name.
+ *
+ * @param name the name of the variable
+ * @param value the value
+ */
+ void setVariable(@NonNull String name, @NonNull String value);
+
+ /**
+ * Removes a variable with the given name. The subsequent call to
+ * {@link #getVariable(java.lang.String)} with the same argument should
+ * return null.
+ *
+ * @param name the name of the variable
+ */
+ void removeVariable(@NonNull String name);
+
+ /**
+ * Returns all variable names and associated values as a {@link Map}.
+ * Changes to the map must not be propagated back to the {@link Environment}.
+ *
+ * @return all variable names and associated values
+ */
+ @NonNull
+ Mapnull in case it
+ * was not configured.
+ *
+ * @return the configured working directory or null in case it
+ * was not configured
+ */
+ @CheckForNull
+ public String getWorkingDirectory() {
+ return workingDirectory;
+ }
+
+ /**
+ * Returns the arguments configured for the process.
+ *
+ * @return the arguments configured for the process
+ */
+ @NonNull
+ public Listtrue if standard error stream should be redirected
+ * to standard output stream.
+ *
+ * @return true if standard error stream should be redirected
+ * to standard output stream
+ */
+ public boolean isRedirectErrorStream() {
+ return redirectErrorStream;
+ }
+
+ /**
+ * Returns the environment variables configured for the process.
+ *
+ * @return the environment variables configured for the process
+ */
+ @NonNull
+ public Map