org.eclipse.jetty.server.handler

## Class ConnectHandler.ProxyToServerConnection

- java.lang.Object
- - org.eclipse.jetty.server.handler.ConnectHandler.ProxyToServerConnection

All Implemented Interfaces:
  Connection, AsyncConnection

Enclosing class:
  ConnectHandler

    public class ConnectHandler.ProxyToServerConnection
    extends Object
    implements AsyncConnection

### Constructor Summary

Constructors
Constructor and Description
`ConnectHandler.ProxyToServerConnection(ConcurrentMap<String,Object> context, Buffer data)`

### Method Summary

Methods
`void` `close()`
`void` `closeClient()`
`void` `closeServer()`
`long` `getTimeStamp()`
`Connection` `handle()` Handle the connection.
`boolean` `isIdle()`
`boolean` `isSuspended()` The semantic of this method is to return true to indicate interest in further reads, or false otherwise, but it is misnamed and should be really called `isReadInterested()`.
`void` `onClose()` Called after the connection is closed
`void` `onIdleExpired(long idleForMs)` Called when the connection idle timeout expires
`void` `onInputShutdown()`
`void` `ready()`
`void` `setConnection(ConnectHandler.ClientToProxyConnection connection)`
`void` `setEndPoint(AsyncEndPoint endpoint)`
`void` `setTimeStamp(long timestamp)`
`void` `shutdownOutput()`
`String` `toString()`
`void` `waitReady(long timeout)`

### Methods inherited from class java.lang.Object

`clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

### Constructor Detail

#### ConnectHandler.ProxyToServerConnection

    public ConnectHandler.ProxyToServerConnection(ConcurrentMap<String,Object> context,
                                          Buffer data)

### Method Detail

#### toString

    public String toString()

Overrides:
  `toString` in class `Object`

#### handle

    public Connection handle()
                      throws IOException

Description copied from interface: `Connection`
Handle the connection.

Specified by:
  `handle` in interface `Connection`
Returns:
  The Connection to use for the next handling of the connection. This allows protocol upgrades and support for CONNECT.
Throws:
  `IOException` - if the handling of I/O operations fail

#### onInputShutdown

    public void onInputShutdown()
                         throws IOException

Specified by:
  `onInputShutdown` in interface `AsyncConnection`
Throws:
  `IOException`

#### setConnection

    public void setConnection(ConnectHandler.ClientToProxyConnection connection)

#### getTimeStamp

    public long getTimeStamp()

Specified by:
  `getTimeStamp` in interface `Connection`
Returns:
  the timestamp at which the connection was created

#### setTimeStamp

    public void setTimeStamp(long timestamp)

#### setEndPoint

    public void setEndPoint(AsyncEndPoint endpoint)

#### isIdle

    public boolean isIdle()

Specified by:
  `isIdle` in interface `Connection`
Returns:
  whether this connection is idle, that is not parsing and not generating
See Also:
  `Connection.onIdleExpired(long)`

#### isSuspended

    public boolean isSuspended()

Description copied from interface: `Connection`

The semantic of this method is to return true to indicate interest in further reads, or false otherwise, but it is misnamed and should be really called `isReadInterested()`.

Specified by:
  `isSuspended` in interface `Connection`
Returns:
  true to indicate interest in further reads, false otherwise

#### onClose

    public void onClose()

Description copied from interface: `Connection`
Called after the connection is closed

Specified by:
  `onClose` in interface `Connection`

#### ready

    public void ready()

#### waitReady

    public void waitReady(long timeout)
                   throws IOException

Throws:
  `IOException`

#### closeClient

    public void closeClient()
                     throws IOException

Throws:
  `IOException`

#### closeServer

    public void closeServer()
                     throws IOException

Throws:
  `IOException`

#### close

    public void close()

#### shutdownOutput

    public void shutdownOutput()
                        throws IOException

Throws:
  `IOException`

#### onIdleExpired

    public void onIdleExpired(long idleForMs)

Description copied from interface: `Connection`
Called when the connection idle timeout expires

Specified by:
  `onIdleExpired` in interface `Connection`
Parameters:
  `idleForMs` - how long the connection has been idle
See Also:
  `Connection.isIdle()`