java.lang.Object
- org.apache.qpid.protonj2.engine.impl.ProtonEngine

All Implemented Interfaces:

Consumer<ProtonBuffer>, Engine
```
public class ProtonEngine
extends Object
implements Engine
```
The default proton Engine implementation.

Constructor Summary

Constructors
Constructor Description

ProtonEngine()

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`ProtonEngineConfiguration`	`configuration()`	Gets the Configuration for this engine.
`ProtonConnection`	`connection()`	Gets the `Connection` instance that is associated with this `Engine` instance.
`EngineStateException`	`engineFailed(Throwable cause)`	Transition the `Engine` to a failed state if not already closed or closing.
`ProtonEngine`	`errorHandler(EventHandler<Engine> handler)`	Sets a handler instance that will be notified when the engine encounters a fatal error.
`Throwable`	`failureCause()`
`ProtonEngine`	`ingest(ProtonBuffer input)`	Provide data input for this Engine from some external source.
`boolean`	`isFailed()`
`boolean`	`isRunning()`
`boolean`	`isShutdown()`
`boolean`	`isWritable()`	Returns true if the engine is accepting input from the ingestion entry points.
`ProtonEngine`	`outputHandler(BiConsumer<ProtonBuffer,Runnable> handler)`	Sets a `BiConsumer` instance that will be notified when data from the engine is ready to be written to some output sink (socket etc).
`EnginePipeline`	`pipeline()`	Gets the EnginePipeline for this Engine.
`void`	`registerSaslDriver(EngineSaslDriver saslDriver)`	Allows for registration of a custom `EngineSaslDriver` that will convey SASL state and configuration for this engine.
`EngineSaslDriver`	`saslDriver()`	Gets the SASL driver for this engine, if no SASL layer is configured then a default no-op driver must be returned that indicates this.
`ProtonEngine`	`shutdown()`	Shutdown the engine preventing any future outbound or inbound processing.
`ProtonEngine`	`shutdownHandler(EventHandler<Engine> handler)`	Sets a handler instance that will be notified when the engine is shut down via a call to the `Engine.shutdown()` method is called.
`ProtonConnection`	`start()`	Starts the engine and returns the `Connection` instance that is bound to this Engine.
`EngineState`	`state()`
`long`	`tick(long currentTime)`	Prompt the engine to perform idle-timeout/heartbeat handling, and return an absolute deadline in milliseconds that tick must again be called by/at, based on the provided current time in milliseconds, to ensure the periodic work is carried out as necessary.
`ProtonEngine`	`tickAuto(ScheduledExecutorService executor)`	Allows the engine to manage idle timeout processing by providing it the single threaded executor context where all transport work is done which ensures singled threaded access while removing the need for the client library or server application to manage calls to the `Engine.tick(long)` methods.

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

Methods inherited from interface java.util.function.Consumer
andThen

Methods inherited from interface org.apache.qpid.protonj2.engine.Engine
accept, outputConsumer, outputHandler

- Constructor Detail
  - ProtonEngine
```
public ProtonEngine()
```
- Method Detail
  - connection
```
public ProtonConnection connection()
```
    Description copied from interface: Engine
    
    Gets the Connection instance that is associated with this Engine instance. It is valid for an engine implementation to not return a Connection instance prior to the engine having been started.
    
    Specified by:
    
    connection in interface Engine
    
    Returns:
    
    the Connection that is linked to this engine instance.
  - isWritable
```
public boolean isWritable()
```
    Description copied from interface: Engine
    
    Returns true if the engine is accepting input from the ingestion entry points.
    When false any attempts to write more data into the engine will result in an error being returned from the write operation. An engine that has not been started or that has been failed or shutdown will report as not writable.
    
    Specified by:
    
    isWritable in interface Engine
    
    Returns:
    
    true if the engine is current accepting more input.
  - isRunning
```
public boolean isRunning()
```
    Specified by:
    
    isRunning in interface Engine
    
    Returns:
    
    true if the Engine has entered the running state and is not failed or shutdown.
  - isShutdown
```
public boolean isShutdown()
```
    Specified by:
    
    isShutdown in interface Engine
    
    Returns:
    
    true if the Engine has been shutdown and is no longer usable.
  - isFailed
```
public boolean isFailed()
```
    Specified by:
    
    isFailed in interface Engine
    
    Returns:
    
    true if the Engine has encountered a critical error and cannot produce new data.
  - failureCause
```
public Throwable failureCause()
```
    Specified by:
    
    failureCause in interface Engine
    
    Returns:
    
    the error that caused the Engine fail and shutdown (or null if not failed).
  - state
```
public EngineState state()
```
    Specified by:
    
    state in interface Engine
    
    Returns:
    
    the current state of the engine.
  - start
```
public ProtonConnection start()
                       throws EngineStateException
```
    Description copied from interface: Engine
    
    Starts the engine and returns the Connection instance that is bound to this Engine. A non-started Engine will not allow ingestion of any inbound data and a Connection linked to the engine that was obtained from the Engine.connection() method cannot produce any outbound data.
    
    Specified by:
    
    start in interface Engine
    
    Returns:
    
    the Connection instance that is linked to this Engine
    
    Throws:
    
    EngineStateException - if the Engine state has already transition to shutdown or failed.
  - shutdown
```
public ProtonEngine shutdown()
```
    Description copied from interface: Engine
    
    Shutdown the engine preventing any future outbound or inbound processing. When the engine is shut down any resources, Connection, Session or Link instances that have an engine shutdown event handler registered will be notified and should react by locally closing that resource if they wish to ensure that the resource's local close event handler gets signaled if that resource is not already locally closed.
    
    Specified by:
    
    shutdown in interface Engine
    
    Returns:
    
    this Engine
  - tick
```
public long tick(long currentTime)
          throws IllegalStateException,
                 EngineStateException
```
    Description copied from interface: Engine
    
    Prompt the engine to perform idle-timeout/heartbeat handling, and return an absolute deadline in milliseconds that tick must again be called by/at, based on the provided current time in milliseconds, to ensure the periodic work is carried out as necessary. It is an error to call this method if the connection has not been opened. A returned deadline of 0 indicates there is no periodic work necessitating tick be called, e.g. because neither peer has defined an idle-timeout value. The provided milliseconds time values should be derived from a monotonic source such as System.nanoTime() to prevent wall clock changes leading to erroneous behaviour. Note that for System.nanoTime() derived values in particular that the returned deadline could be a different sign than the originally given value, and so (if non-zero) the returned deadline should have the current time originally provided subtracted from it in order to establish a relative time delay to the next deadline. Supplying System.currentTimeMillis() derived values can lead to erroneous behaviour during wall clock changes and so is not recommended. It is an error to call this method if Engine.tickAuto(ScheduledExecutorService) was called.
    
    Specified by:
    
    tick in interface Engine
    
    Parameters:
    
    currentTime - the current time of this tick call.
    
    Returns:
    
    the absolute deadline in milliseconds to next call tick by/at, or 0 if there is none.
    
    Throws:
    
    IllegalStateException - if the Engine is already performing auto tick handling.
    
    EngineStateException - if the Engine state precludes accepting new input.
  - tickAuto
```
public ProtonEngine tickAuto(ScheduledExecutorService executor)
                      throws IllegalStateException,
                             EngineStateException
```
    Description copied from interface: Engine
    
    Allows the engine to manage idle timeout processing by providing it the single threaded executor context where all transport work is done which ensures singled threaded access while removing the need for the client library or server application to manage calls to the Engine.tick(long) methods.
    
    Specified by:
    
    tickAuto in interface Engine
    
    Parameters:
    
    executor - The single threaded execution context where all engine work takes place.
    
    Returns:
    
    this Engine
    
    Throws:
    
    IllegalStateException - if the Engine is already performing auto tick handling.
    
    EngineStateException - if the Engine state precludes accepting new input.
  - ingest
```
public ProtonEngine ingest(ProtonBuffer input)
                    throws EngineStateException
```
    Description copied from interface: Engine
    
    Provide data input for this Engine from some external source. If the engine is not writable when this method is called an EngineNotWritableException will be thrown if unless the reason for the not writable state is due to engine failure or the engine already having been shut down in which case the appropriate EngineStateException will be thrown to indicate the reason.
    
    Specified by:
    
    ingest in interface Engine
    
    Parameters:
    
    input - The data to feed into to Engine.
    
    Returns:
    
    this Engine
    
    Throws:
    
    EngineStateException - if the Engine state precludes accepting new input.
  - engineFailed
```
public EngineStateException engineFailed(Throwable cause)
```
    Description copied from interface: Engine
    
    Transition the Engine to a failed state if not already closed or closing. If called when the engine has not failed the engine will be transitioned to the failed state and the method will return an appropriate EngineFailedException that wraps the given cause. If called after the engine was shutdown the method returns an EngineShutdownException indicating that the engine was already shutdown. Repeated calls to this method while the engine is in the failed state must not alter the original failure error or elicit new engine failed event notifications.
    
    Specified by:
    
    engineFailed in interface Engine
    
    Parameters:
    
    cause - The exception that caused the engine to be forcibly transitioned to the failed state.
    
    Returns:
    
    an EngineStateException that can be thrown indicating the failure and engine state.
  - outputHandler
```
public ProtonEngine outputHandler(BiConsumer<ProtonBuffer,Runnable> handler)
```
    Description copied from interface: Engine
    
    Sets a BiConsumer instance that will be notified when data from the engine is ready to be written to some output sink (socket etc). The Runnable value provided (if non-null) should be invoked once the I/O operation has completely successfully. If the event of an error writing the data the handler should throw an error or if performed asynchronously the Engine should be marked failed via a call to Engine.engineFailed(Throwable).
    
    Specified by:
    
    outputHandler in interface Engine
    
    Parameters:
    
    handler - The ProtonBuffer handler instance that performs IO for the engine output.
    
    Returns:
    
    this Engine
  - errorHandler
```
public ProtonEngine errorHandler(EventHandler<Engine> handler)
```
    Description copied from interface: Engine
    
    Sets a handler instance that will be notified when the engine encounters a fatal error.
    
    Specified by:
    
    errorHandler in interface Engine
    
    Parameters:
    
    handler - The ProtonException handler instance that will be notified if the engine fails.
    
    Returns:
    
    this Engine
  - shutdownHandler
```
public ProtonEngine shutdownHandler(EventHandler<Engine> handler)
```
    Description copied from interface: Engine
    
    Sets a handler instance that will be notified when the engine is shut down via a call to the Engine.shutdown() method is called.
    
    Specified by:
    
    shutdownHandler in interface Engine
    
    Parameters:
    
    handler - The Engine instance that was was explicitly shut down.
    
    Returns:
    
    this Engine
  - pipeline
```
public EnginePipeline pipeline()
```
    Description copied from interface: Engine
    
    Gets the EnginePipeline for this Engine.
    
    Specified by:
    
    pipeline in interface Engine
    
    Returns:
    
    the EnginePipeline for this Engine.
  - configuration
```
public ProtonEngineConfiguration configuration()
```
    Description copied from interface: Engine
    
    Gets the Configuration for this engine.
    
    Specified by:
    
    configuration in interface Engine
    
    Returns:
    
    the configuration object for this engine.
  - saslDriver
```
public EngineSaslDriver saslDriver()
```
    Description copied from interface: Engine
    
    Gets the SASL driver for this engine, if no SASL layer is configured then a default no-op driver must be returned that indicates this. The SASL driver provides the engine with client and server side SASL handshaking support. An Engine implementation can support pluggable SASL drivers or exert tight control over the driver as it sees fit.
    
    Specified by:
    
    saslDriver in interface Engine
    
    Returns:
    
    the SASL driver for the engine.
  - registerSaslDriver
```
public void registerSaslDriver(EngineSaslDriver saslDriver)
                        throws EngineStateException
```
    Allows for registration of a custom EngineSaslDriver that will convey SASL state and configuration for this engine.
    
    Parameters:
    
    saslDriver - The EngineSaslDriver that this engine will use.
    
    Throws:
    
    EngineStateException - if the engine state doesn't allow for changes

Class ProtonEngine

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.function.Consumer

Methods inherited from interface org.apache.qpid.protonj2.engine.Engine

Constructor Detail

ProtonEngine

Method Detail

connection

isWritable

isRunning

isShutdown

isFailed

failureCause

state

start

shutdown

tick

tickAuto

ingest

engineFailed

outputHandler

errorHandler

shutdownHandler

pipeline

configuration

saslDriver

registerSaslDriver