Channel (Jenkins remoting layer 2.53.2 API)

java.lang.Object
- hudson.remoting.Channel

All Implemented Interfaces:

VirtualChannel, Closeable, AutoCloseable
```
public class Channel
extends Object
implements VirtualChannel, Closeable
```
Represents a communication channel to the remote peer.
A Channel is a mechanism for two JVMs to communicate over bi-directional InputStream/OutputStream pair. Channel represents an endpoint of the stream, and thus two Channels are always used in a pair.
Communication is established as soon as two Channel instances are created at the end fo the stream pair until the stream is terminated via close().
The basic unit of remoting is an executable Callable object. An application can create a Callable object, and execute it remotely by using the call(Callable) method or callAsync(Callable) method.
In this sense, Channel is a mechanism to delegate/offload computation to other JVMs and somewhat like an agent system. This is bit different from remoting technologies like CORBA or web services, where the server exposes a certain functionality that clients invoke.
Callable object, as well as the return value / exceptions, are transported by using Java serialization. All the necessary class files are also shipped over Channel on-demand, so there's no need to pre-deploy such classes on both JVMs.
Implementor's Note

Channel builds its features in a layered model. Its higher-layer features are built on top of its lower-layer features, and they are called layer-0, layer-1, etc.
- Layer 0: See Command for more details. This is for higher-level features, and not likely useful for applications directly.
- Layer 1: See Request for more details. This is for higher-level features, and not likely useful for applications directly.
Author:

Kohsuke Kawaguchi

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Channel.Listener` Callback "interface" for changes in the state of `Channel`.
`static class`	`Channel.Mode` Communication mode used in conjunction with `ClassicCommandTransport`.

Field Summary

Fields
Modifier and Type	Field and Description
`AtomicInteger`	`classLoadingCount` Total counts of remote classloading activities.
`AtomicInteger`	`classLoadingPrefetchCacheCount` Prefetch cache hits.
`AtomicLong`	`classLoadingTime` Total number of nanoseconds spent for remote class loading.
`static int`	`PIPE_WINDOW_SIZE` Default pipe window size.
`Capability`	`remoteCapability` Capability of the remote `Channel`.
`AtomicInteger`	`resourceLoadingCount` Total count of remote resource loading.
`AtomicLong`	`resourceLoadingTime` Total number of nanoseconds spent for remote resource loading.

Constructor Summary

Constructors
Modifier	Constructor and Description
`protected`	`Channel(ChannelBuilder settings, CommandTransport transport)`
	`Channel(String name, ExecutorService exec, Channel.Mode mode, InputStream is, OutputStream os)` Deprecated. as of 2.24 Use `ChannelBuilder`
	`Channel(String name, ExecutorService exec, Channel.Mode mode, InputStream is, OutputStream os, OutputStream header)` Deprecated. as of 2.24 Use `ChannelBuilder`
	`Channel(String name, ExecutorService exec, Channel.Mode mode, InputStream is, OutputStream os, OutputStream header, boolean restricted)` Deprecated. as of 2.24 Use `ChannelBuilder`
	`Channel(String name, ExecutorService exec, Channel.Mode mode, InputStream is, OutputStream os, OutputStream header, boolean restricted, ClassLoader base)` Deprecated. as of 2.24 Use `ChannelBuilder`
	`Channel(String name, ExecutorService exec, CommandTransport transport, boolean restricted, ClassLoader base)` Deprecated. as of 2.24 Use `ChannelBuilder`
	`Channel(String name, ExecutorService exec, CommandTransport transport, boolean restricted, ClassLoader base, JarCache jarCache)` Deprecated. as of 2.38
	`Channel(String name, ExecutorService exec, InputStream is, OutputStream os)` Deprecated. as of 2.24 Use `ChannelBuilder`
	`Channel(String name, ExecutorService exec, InputStream is, OutputStream os, OutputStream header)` Deprecated. as of 2.24 Use `ChannelBuilder`

Method Summary

Methods
Modifier and Type	Method and Description
`void`	`addListener(Channel.Listener l)` Registers a new `Channel.Listener`.
`void`	`addLocalExecutionInterceptor(CallableDecorator decorator)` Adds a `CallableFilter` that gets a chance to decorate every `Callable`s that run locally sent by the other peer.
`void`	`addLocalExecutionInterceptor(CallableFilter filter)` Deprecated. use `addLocalExecutionInterceptor(CallableDecorator)`
`<V,T extends Throwable> V`	`call(Callable<V,T> callable)` Makes a remote procedure call.
`<V,T extends Throwable> Future<V>`	`callAsync(Callable<V,T> callable)` Makes an asynchronous remote procedure call.
`void`	`close()` Performs an orderly shut down of this channel (and the remote peer.)
`void`	`close(Throwable diagnosis)` Closes the channel.
`ListeningPort`	`createLocalToRemotePortForwarding(int recvPort, String forwardHost, int forwardPort)` Starts a local to remote port forwarding (the equivalent of "ssh -L").
`ListeningPort`	`createRemoteToLocalPortForwarding(int recvPort, String forwardHost, int forwardPort)` Starts a remote to local port forwarding (the equivalent of "ssh -R").
`static Channel`	`current()` This method can be invoked during the serialization/deserialization of objects when they are transferred to the remote `Channel`, as well as during `Callable.call()` is invoked.
`void`	`dumpExportTable(PrintWriter w)` Dumps the list of exported objects and their allocation traces to the given output.
`void`	`dumpPerformanceCounters(PrintWriter w)` Print the performance counters.
`<T> T`	`export(Class<T> type, T instance)` Exports an object for remoting to the other `Channel` by creating a remotable proxy.
`JarCache`	`getJarCache()` If this channel is built with jar file caching, return the object that manages this cache.
`long`	`getLastHeard()` TODO: this is not safe against clock skew and is called from jenkins core (and potentially plugins)
`String`	`getName()`
`<T> T`	`getProperty(ChannelProperty<T> key)`
`Object`	`getProperty(Object key)` Gets the application specific property set by `setProperty(Object, Object)`.
`<T> T`	`getRemoteProperty(ChannelProperty<T> key)`
`Object`	`getRemoteProperty(Object key)` Gets the property set on the remote peer.
`OutputStream`	`getUnderlyingOutput()` Deprecated. Future version of the remoting module may add other modes of creating channel that doesn't involve stream pair. Therefore, we aren't committing to this method. This method isn't a part of the committed API of the channel class.
`boolean`	`isArbitraryCallableAllowed()`
`boolean`	`isClosingOrClosed()` Returns `true` if the channel is either in the process of closing down or has closed down.
`boolean`	`isInClosed()` If the receiving end of the channel is closed (that is, if we are guaranteed to receive nothing further), this method returns true.
`boolean`	`isOutClosed()` Is the sender side of the transport already closed?
`boolean`	`isRemoteClassLoadingAllowed()`
`boolean`	`isRestricted()` Deprecated. Use methods like `isRemoteClassLoadingAllowed()` and `isArbitraryCallableAllowed()` to test individual features.
`void`	`join()` Waits for this `Channel` to be closed down.
`void`	`join(long timeout)` Waits for this `Channel` to be closed down, but only up the given milliseconds.
`void`	`pin(Object instance)` Increase reference count so much to effectively prevent de-allocation.
`void`	`pinClassLoader(ClassLoader cl)` Pin down the exported classloader.
`boolean`	`preloadJar(Callable<?,?> classLoaderRef, Class... classesInJar)` Preloads jar files on the remote side.
`boolean`	`preloadJar(ClassLoader local, Class... classesInJar)`
`boolean`	`preloadJar(ClassLoader local, URL... jars)`
`boolean`	`removeListener(Channel.Listener l)` Removes a listener.
`void`	`removeLocalExecutionInterceptor(CallableDecorator decorator)` Removes the filter introduced by `addLocalExecutionInterceptor(CallableFilter)`.
`void`	`removeLocalExecutionInterceptor(CallableFilter filter)` Deprecated. use `removeLocalExecutionInterceptor(CallableDecorator)`
`void`	`resetPerformanceCounters()` Resets all the performance counters.
`void`	`setArbitraryCallableAllowed(boolean b)`
`void`	`setJarCache(JarCache jarCache)` You can change the `JarCache` while the channel is in operation, but doing so doesn't impact `RemoteClassLoader`s that are already created.
`void`	`setMaximumBytecodeLevel(short level)` Sets the maximum bytecode version (~ JDK) that we expect this channel to be able to load.
`<T> T`	`setProperty(ChannelProperty<T> key, T value)`
`Object`	`setProperty(Object key, Object value)` Sets the property value on this side of the channel.
`void`	`setRemoteClassLoadingAllowed(boolean b)` Controls whether or not this channel is willing to load classes from the other side.
`void`	`setRestricted(boolean b)` Deprecated. Use methods like `setRemoteClassLoadingAllowed(boolean)` and `setArbitraryCallableAllowed(boolean)` to control individual features.
`hudson.remoting.ExportTable.ExportList`	`startExportRecording()`
`void`	`syncIO()` Blocks until all the I/O packets sent before this gets fully executed by the remote side, then return.
`void`	`syncLocalIO()` Blocks until all the I/O packets sent from remote is fully locally executed, then return.
`void`	`terminate(IOException e)` Aborts the connection in response to an error.
`String`	`toString()`
`<T> T`	`waitForProperty(ChannelProperty<T> key)`
`Object`	`waitForProperty(Object key)` Works like `getProperty(Object)` but wait until some value is set by someone.
`<T> T`	`waitForRemoteProperty(ChannelProperty<T> key)` Deprecated. Because `ChannelProperty` is identity-equality, this method would never work. This is a design error.
`Object`	`waitForRemoteProperty(Object key)` Gets the property set on the remote peer.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Field Detail
  - classLoadingTime
```
public final AtomicLong classLoadingTime
```
    Total number of nanoseconds spent for remote class loading.
    Remote code execution often results in classloading activity (more precisely, when the remote peer requests some computation on this channel, this channel often has to load necessary classes from the remote peer.)
    This counter represents the total amount of time this channel had to spend loading classes from the remote peer. The time measurement doesn't include the time locally spent to actually define the class (as the local classloading would have incurred the same cost.)
  - classLoadingCount
```
public final AtomicInteger classLoadingCount
```
    Total counts of remote classloading activities. Used in a pair with classLoadingTime.
  - classLoadingPrefetchCacheCount
```
public final AtomicInteger classLoadingPrefetchCacheCount
```
    Prefetch cache hits. Out of all the counts in classLoadingCount, how many times were we able to resolve them by ourselves, saving a remote roundtrip call?
    
    Since:
    
    2.24
  - resourceLoadingTime
```
public final AtomicLong resourceLoadingTime
```
    Total number of nanoseconds spent for remote resource loading.
    
    See Also:
    classLoadingTime
  - resourceLoadingCount
```
public final AtomicInteger resourceLoadingCount
```
    Total count of remote resource loading.
    
    See Also:
    classLoadingCount
  - remoteCapability
```
public final Capability remoteCapability
```
    Capability of the remote Channel.
  - PIPE_WINDOW_SIZE
```
public static final int PIPE_WINDOW_SIZE
```
    Default pipe window size.
    This controls the amount of bytes that can be in flight. Value too small would fail to efficiently utilize a high-latency/large-bandwidth network, but a value too large would cause the risk of a large memory consumption when a pipe clogs (that is, the receiver isn't consuming bytes we are sending fast enough.)
    If we have a gigabit ethernet (with effective transfer rate of 100M bps) and 20ms latency, the pipe will hold (100M bits/sec * 0.02sec / 8 bits/byte = 0.25MB. So 1MB or so is big enough for most network, and hopefully this is an acceptable enough memory consumption in case of clogging.
    
    See Also:
    PipeWindow
- Constructor Detail
  - Channel
```
@Deprecated
public Channel(String name,
                  ExecutorService exec,
                  InputStream is,
                  OutputStream os)
        throws IOException
```
    Deprecated. as of 2.24 Use ChannelBuilder
    
    Throws:
    
    IOException
  - Channel
```
@Deprecated
public Channel(String name,
                  ExecutorService exec,
                  Channel.Mode mode,
                  InputStream is,
                  OutputStream os)
        throws IOException
```
    Deprecated. as of 2.24 Use ChannelBuilder
    
    Throws:
    
    IOException
  - Channel
```
@Deprecated
public Channel(String name,
                  ExecutorService exec,
                  InputStream is,
                  OutputStream os,
                  OutputStream header)
        throws IOException
```
    Deprecated. as of 2.24 Use ChannelBuilder
    
    Throws:
    
    IOException
  - Channel
```
@Deprecated
public Channel(String name,
                  ExecutorService exec,
                  Channel.Mode mode,
                  InputStream is,
                  OutputStream os,
                  OutputStream header)
        throws IOException
```
    Deprecated. as of 2.24 Use ChannelBuilder
    
    Throws:
    
    IOException
  - Channel
```
@Deprecated
public Channel(String name,
                  ExecutorService exec,
                  Channel.Mode mode,
                  InputStream is,
                  OutputStream os,
                  OutputStream header,
                  boolean restricted)
        throws IOException
```
    Deprecated. as of 2.24 Use ChannelBuilder
    
    Throws:
    
    IOException
  - Channel
```
@Deprecated
public Channel(String name,
                  ExecutorService exec,
                  Channel.Mode mode,
                  InputStream is,
                  OutputStream os,
                  OutputStream header,
                  boolean restricted,
                  ClassLoader base)
        throws IOException
```
    Deprecated. as of 2.24 Use ChannelBuilder
    
    Creates a new channel.
    
    Parameters:
    restricted -
    
    Throws:
    
    IOException
  - Channel
```
@Deprecated
public Channel(String name,
                  ExecutorService exec,
                  CommandTransport transport,
                  boolean restricted,
                  ClassLoader base)
        throws IOException
```
    Deprecated. as of 2.24 Use ChannelBuilder
    
    Throws:
    
    IOException
    Since:
    
    2.13
  - Channel
```
@Deprecated
public Channel(String name,
                  ExecutorService exec,
                  CommandTransport transport,
                  boolean restricted,
                  ClassLoader base,
                  JarCache jarCache)
        throws IOException
```
    Deprecated. as of 2.38
    
    Creates a new channel.
    
    Parameters:
    name - See Channel(String, ExecutorService, Mode, InputStream, OutputStream, OutputStream, boolean, ClassLoader)
    exec - See Channel(String, ExecutorService, Mode, InputStream, OutputStream, OutputStream, boolean, ClassLoader)
    transport - The transport that we run Channel on top of.
    base - See Channel(String, ExecutorService, Mode, InputStream, OutputStream, OutputStream, boolean, ClassLoader)
    restricted - See Channel(String, ExecutorService, Mode, InputStream, OutputStream, OutputStream, boolean, ClassLoader)
    jarCache -
    
    Throws:
    
    IOException
    Since:
    
    2.24
  - Channel
```
protected Channel(ChannelBuilder settings,
       CommandTransport transport)
           throws IOException
```
    Throws:
    
    IOException
    Since:
    
    TODO
- Method Detail
  - isOutClosed
```
public boolean isOutClosed()
```
    Is the sender side of the transport already closed?
  - isClosingOrClosed
```
public boolean isClosingOrClosed()
```
    Returns true if the channel is either in the process of closing down or has closed down.
    
    Since:
    
    2.33
  - export
```
public <T> T export(Class<T> type,
           T instance)
```
    Exports an object for remoting to the other Channel by creating a remotable proxy.
    All the parameters and return values must be serializable.
    
    Specified by:
    
    export in interface VirtualChannel
    
    Parameters:
    type - Interface to be remoted.
    
    Returns:
    the proxy object that implements T. This object can be transfered to the other Channel, and calling methods on it from the remote side will invoke the same method on the given local instance object.
  - pin
```
public void pin(Object instance)
```
    Increase reference count so much to effectively prevent de-allocation.
    
    See Also:
    ExportTable.Entry.pin()
  - pinClassLoader
```
public void pinClassLoader(ClassLoader cl)
```
    Pin down the exported classloader.
  - preloadJar
```
public boolean preloadJar(Callable<?,?> classLoaderRef,
                 Class... classesInJar)
                   throws IOException,
                          InterruptedException
```
    Preloads jar files on the remote side.
    This is a performance improvement method that can be safely ignored if your goal is just to make things working.
    Normally, classes are transferred over the network one at a time, on-demand. This design is mainly driven by how Java classloading works — we can't predict what classes will be necessarily upfront very easily.
    Classes are loaded only once, so for long-running Channel, this is normally an acceptable overhead. But sometimes, for example when a channel is short-lived, or when you know that you'll need a majority of classes in certain jar files, then it is more efficient to send a whole jar file over the network upfront and thereby avoiding individual class transfer over the network.
    That is what this method does. It ensures that a series of jar files are copied to the remote side (AKA "preloading.") Classloading will consult the preloaded jars before performing network transfer of class files.
    Beware that this method is not useful in all configurations. If a RemoteClassLoader has another RemoteClassLoader as a parent, which would be typical, then preloading a JAR in it will not reduce network round-trips: each class load still has to call loadClass on the parent, which will wind up checking the remote side just to get a negative answer.
    
    Parameters:
    classLoaderRef - This parameter is used to identify the remote classloader that will prefetch the specified jar files. That is, prefetching will ensure that prefetched jars will kick in when this Callable object is actually executed remote side.
    RemoteClassLoaders are created wisely, one per local ClassLoader, so this parameter doesn't have to be exactly the same Callable to be executed later — it just has to be of the same class.
    classesInJar - Class objects that identify jar files to be preloaded. Jar files that contain the specified classes will be preloaded into the remote peer. You just need to specify one class per one jar.
    
    Returns:
    true if the preloading actually happened. false if all the jars are already preloaded. This method is implemented in such a way that unnecessary jar file transfer will be avoided, and the return value will tell you if this optimization kicked in. Under normal circumstances your program shouldn't depend on this return value. It's just a hint.
    
    Throws:
    
    IOException - if the preloading fails.
    
    InterruptedException
  - preloadJar
```
public boolean preloadJar(ClassLoader local,
                 Class... classesInJar)
                   throws IOException,
                          InterruptedException
```
    Throws:
    
    IOException
    
    InterruptedException
  - preloadJar
```
public boolean preloadJar(ClassLoader local,
                 URL... jars)
                   throws IOException,
                          InterruptedException
```
    Throws:
    
    IOException
    
    InterruptedException
  - getJarCache
```
public JarCache getJarCache()
```
    If this channel is built with jar file caching, return the object that manages this cache.
    
    Since:
    
    2.24
  - setJarCache
```
public void setJarCache(JarCache jarCache)
```
    You can change the JarCache while the channel is in operation, but doing so doesn't impact RemoteClassLoaders that are already created. So to best avoid performance loss due to race condition, please set a JarCache in the constructor, unless your call sequence guarantees that you call this method before remote classes are loaded.
    
    Since:
    
    2.24
  - call
```
public <V,T extends Throwable> V call(Callable<V,T> callable)
       throws IOException,
              T extends Throwable,
              InterruptedException
```
    Makes a remote procedure call.
    Sends Callable to the remote system, executes it, and returns its result.
    
    Specified by:
    
    call in interface VirtualChannel
    
    Throws:
    
    IOException - If there's any error in the communication between Channels.
    
    InterruptedException - If the current thread is interrupted while waiting for the completion.
    
    T extends Throwable
  - callAsync
```
public <V,T extends Throwable> Future<V> callAsync(Callable<V,T> callable)
                    throws IOException
```
    Makes an asynchronous remote procedure call.
    Similar to VirtualChannel.call(Callable) but returns immediately. The result of the Callable can be obtained through the Future object.
    
    Specified by:
    
    callAsync in interface VirtualChannel
    
    Returns:
    The Future object that can be used to wait for the completion.
    
    Throws:
    
    IOException - If there's an error during the communication.
  - terminate
```
public void terminate(IOException e)
```
    Aborts the connection in response to an error. This is an SPI for CommandTransport implementation to notify Channel when the underlying connection is severed.
    
    Parameters:
    e - The error that caused the connection to be aborted. Never null.
  - addListener
```
public void addListener(Channel.Listener l)
```
    Registers a new Channel.Listener.
    
    See Also:
    removeListener(Listener)
  - removeListener
```
public boolean removeListener(Channel.Listener l)
```
    Removes a listener.
    
    Returns:
    false if the given listener has not been registered to begin with.
  - addLocalExecutionInterceptor
```
public void addLocalExecutionInterceptor(CallableDecorator decorator)
```
    Adds a CallableFilter that gets a chance to decorate every Callables that run locally sent by the other peer. This is useful to tweak the environment those closures are run, such as setting up the thread context environment.
  - removeLocalExecutionInterceptor
```
public void removeLocalExecutionInterceptor(CallableDecorator decorator)
```
    Removes the filter introduced by addLocalExecutionInterceptor(CallableFilter).
  - addLocalExecutionInterceptor
```
@Deprecated
public void addLocalExecutionInterceptor(CallableFilter filter)
```
    Deprecated. use addLocalExecutionInterceptor(CallableDecorator)
  - removeLocalExecutionInterceptor
```
@Deprecated
public void removeLocalExecutionInterceptor(CallableFilter filter)
```
    Deprecated. use removeLocalExecutionInterceptor(CallableDecorator)
  - join
```
public void join()
          throws InterruptedException
```
    Waits for this Channel to be closed down. The close-down of a Channel might be initiated locally or remotely.
    
    Specified by:
    
    join in interface VirtualChannel
    
    Throws:
    
    InterruptedException - If the current thread is interrupted while waiting for the completion.
  - isInClosed
```
public boolean isInClosed()
```
    If the receiving end of the channel is closed (that is, if we are guaranteed to receive nothing further), this method returns true.
  - isRestricted
```
@Deprecated
public boolean isRestricted()
```
    Deprecated. Use methods like isRemoteClassLoadingAllowed() and isArbitraryCallableAllowed() to test individual features.
    
    Returns true if this channel has any of the security restrictions enabled.
  - setRestricted
```
@Deprecated
public void setRestricted(boolean b)
```
    Deprecated. Use methods like setRemoteClassLoadingAllowed(boolean) and setArbitraryCallableAllowed(boolean) to control individual features.
    
    Activates/disables all the security restriction mode.
  - isRemoteClassLoadingAllowed
```
public boolean isRemoteClassLoadingAllowed()
```
    Since:
    
    TODO
  - setRemoteClassLoadingAllowed
```
public void setRemoteClassLoadingAllowed(boolean b)
```
    Controls whether or not this channel is willing to load classes from the other side. The default is on.
    
    Since:
    
    TODO
  - isArbitraryCallableAllowed
```
public boolean isArbitraryCallableAllowed()
```
    Since:
    
    TODO
  - setArbitraryCallableAllowed
```
public void setArbitraryCallableAllowed(boolean b)
```
    Since:
    
    TODO
    
    See Also:
    ChannelBuilder.withArbitraryCallableAllowed(boolean)
  - setMaximumBytecodeLevel
```
public void setMaximumBytecodeLevel(short level)
                             throws IOException,
                                    InterruptedException
```
    Sets the maximum bytecode version (~ JDK) that we expect this channel to be able to load. If attempts are made to load remote classes using newer bytecode, they are immediately rejected, even if the remote JVM is actually new enough to load it. This helps maintain compatibility by making tests fail immediately without the need for an old JDK installation. By default, the remote class loader will try to load any bytecode version.
    
    Parameters:
    level - e.g. 5 for JDK 5 (the minimum sensible value)
    
    Throws:
    
    IOException
    
    InterruptedException
    Since:
    
    2.29
  - join
```
public void join(long timeout)
          throws InterruptedException
```
    Waits for this Channel to be closed down, but only up the given milliseconds.
    
    Specified by:
    
    join in interface VirtualChannel
    
    Throws:
    
    InterruptedException - If the current thread is interrupted while waiting for the completion.
    Since:
    
    1.299
  - resetPerformanceCounters
```
public void resetPerformanceCounters()
```
    Resets all the performance counters.
  - dumpPerformanceCounters
```
public void dumpPerformanceCounters(PrintWriter w)
                             throws IOException
```
    Print the performance counters.
    
    Throws:
    
    IOException
    Since:
    
    2.24
  - close
```
public void close()
           throws IOException
```
    Performs an orderly shut down of this channel (and the remote peer.)
    
    Specified by:
    
    close in interface VirtualChannel
    
    Specified by:
    
    close in interface Closeable
    
    Specified by:
    
    close in interface AutoCloseable
    
    Throws:
    
    IOException - if the orderly shut-down failed.
  - close
```
public void close(Throwable diagnosis)
           throws IOException
```
    Closes the channel.
    
    Parameters:
    diagnosis - If someone (either this side or the other side) tries to use a channel that's already closed, they'll get a stack trace indicating that the channel has already been closed. This diagnosis, if provided, will further chained to that exception, providing more contextual information about why the channel was closed.
    
    Throws:
    
    IOException
    Since:
    
    2.8
  - getProperty
```
public Object getProperty(Object key)
```
    Gets the application specific property set by setProperty(Object, Object). These properties are also accessible from the remote channel via getRemoteProperty(Object).
    This mechanism can be used for one side to discover contextual objects created by the other JVM (as opposed to executing Callable, which cannot have any reference to the context of the remote Channel.
  - getProperty
```
public <T> T getProperty(ChannelProperty<T> key)
```
  - waitForProperty
```
public Object waitForProperty(Object key)
                       throws InterruptedException
```
    Works like getProperty(Object) but wait until some value is set by someone.
    
    Throws:
    
    IllegalStateException - if the channel is closed. The idea is that channel properties are expected to be the coordination mechanism between two sides of the channel, and this method in particular is a way of one side to wait for the set by the other side of the channel (via waitForRemoteProperty(Object). If we don't abort after the channel shutdown, this method will block forever.
    
    InterruptedException
  - waitForProperty
```
public <T> T waitForProperty(ChannelProperty<T> key)
                  throws InterruptedException
```
    Throws:
    
    InterruptedException
  - setProperty
```
public Object setProperty(Object key,
                 Object value)
```
    Sets the property value on this side of the channel.
    
    See Also:
    getProperty(Object)
  - setProperty
```
public <T> T setProperty(ChannelProperty<T> key,
                T value)
```
  - getRemoteProperty
```
public Object getRemoteProperty(Object key)
```
    Gets the property set on the remote peer.
    
    Returns:
    null if the property of the said key isn't set.
  - getRemoteProperty
```
public <T> T getRemoteProperty(ChannelProperty<T> key)
```
  - waitForRemoteProperty
```
public Object waitForRemoteProperty(Object key)
                             throws InterruptedException
```
    Gets the property set on the remote peer. This method blocks until the property is set by the remote peer.
    
    Throws:
    
    InterruptedException
  - waitForRemoteProperty
```
@Deprecated
public <T> T waitForRemoteProperty(ChannelProperty<T> key)
                        throws InterruptedException
```
    Deprecated. Because ChannelProperty is identity-equality, this method would never work. This is a design error.
    
    Throws:
    
    InterruptedException
  - getUnderlyingOutput
```
@Deprecated
public OutputStream getUnderlyingOutput()
```
    Deprecated. Future version of the remoting module may add other modes of creating channel that doesn't involve stream pair. Therefore, we aren't committing to this method. This method isn't a part of the committed API of the channel class.
    
    Obtain the output stream passed to the constructor.
    
    Returns:
    While the current version always return a non-null value, the caller must not make that assumption for the above reason. This method may return null in the future version to indicate that the Channel is not sitting on top of a stream pair.
  - createLocalToRemotePortForwarding
```
public ListeningPort createLocalToRemotePortForwarding(int recvPort,
                                              String forwardHost,
                                              int forwardPort)
                                                throws IOException,
                                                       InterruptedException
```
    Starts a local to remote port forwarding (the equivalent of "ssh -L").
    
    Parameters:
    recvPort - The port on this local machine that we'll listen to. 0 to let OS pick a random available port. If you specify 0, use ListeningPort.getPort() to figure out the actual assigned port.
    forwardHost - The remote host that the connection will be forwarded to. Connection to this host will be made from the other JVM that this Channel represents.
    forwardPort - The remote port that the connection will be forwarded to.
    
    Returns:
    
    Throws:
    
    IOException
    
    InterruptedException
  - createRemoteToLocalPortForwarding
```
public ListeningPort createRemoteToLocalPortForwarding(int recvPort,
                                              String forwardHost,
                                              int forwardPort)
                                                throws IOException,
                                                       InterruptedException
```
    Starts a remote to local port forwarding (the equivalent of "ssh -R").
    
    Parameters:
    recvPort - The port on the remote JVM (represented by this Channel) that we'll listen to. 0 to let OS pick a random available port. If you specify 0, use ListeningPort.getPort() to figure out the actual assigned port.
    forwardHost - The remote host that the connection will be forwarded to. Connection to this host will be made from this JVM.
    forwardPort - The remote port that the connection will be forwarded to.
    
    Returns:
    
    Throws:
    
    IOException
    
    InterruptedException
  - syncIO
```
public void syncIO()
            throws IOException,
                   InterruptedException
```
    Blocks until all the I/O packets sent before this gets fully executed by the remote side, then return.
    
    Throws:
    
    IOException - If the remote doesn't support this operation, or if sync fails for other reasons.
    
    InterruptedException
  - syncLocalIO
```
public void syncLocalIO()
                 throws InterruptedException
```
    Description copied from interface: VirtualChannel
    
    Blocks until all the I/O packets sent from remote is fully locally executed, then return.
    
    Specified by:
    
    syncLocalIO in interface VirtualChannel
    
    Throws:
    
    InterruptedException
  - getName
```
public String getName()
```
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - dumpExportTable
```
public void dumpExportTable(PrintWriter w)
                     throws IOException
```
    Dumps the list of exported objects and their allocation traces to the given output.
    
    Throws:
    
    IOException
  - startExportRecording
```
public hudson.remoting.ExportTable.ExportList startExportRecording()
```
  - getLastHeard
```
public long getLastHeard()
```
    TODO: this is not safe against clock skew and is called from jenkins core (and potentially plugins)
    
    See Also:
    lastHeard
  - current
```
public static Channel current()
```
    This method can be invoked during the serialization/deserialization of objects when they are transferred to the remote Channel, as well as during Callable.call() is invoked.
    
    Returns:
    null if the calling thread is not performing serialization.

Class Channel

Implementor's Note

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

classLoadingTime

classLoadingCount

classLoadingPrefetchCacheCount

resourceLoadingTime

resourceLoadingCount

remoteCapability

PIPE_WINDOW_SIZE

Constructor Detail

Channel

Channel

Channel

Channel

Channel

Channel

Channel

Channel

Channel

Method Detail

isOutClosed

isClosingOrClosed

export

pin

pinClassLoader

preloadJar

preloadJar

preloadJar

getJarCache

setJarCache

call

callAsync

terminate

addListener

removeListener

addLocalExecutionInterceptor

removeLocalExecutionInterceptor

addLocalExecutionInterceptor

removeLocalExecutionInterceptor

join

isInClosed

isRestricted

setRestricted

isRemoteClassLoadingAllowed

setRemoteClassLoadingAllowed

isArbitraryCallableAllowed

setArbitraryCallableAllowed

setMaximumBytecodeLevel

join

resetPerformanceCounters

dumpPerformanceCounters

close

close

getProperty

getProperty

waitForProperty

waitForProperty

setProperty

setProperty

getRemoteProperty

getRemoteProperty

waitForRemoteProperty

waitForRemoteProperty

getUnderlyingOutput

createLocalToRemotePortForwarding

createRemoteToLocalPortForwarding

syncIO

syncLocalIO

getName

toString

dumpExportTable

startExportRecording

getLastHeard

current