RBroker (DeployR Java RBroker Framework)

```
public interface RBroker
```
Represents a high-level programming model for building DeployR-enabled client applications. By using RBroker an application developer can focus entirely on integrating R Analytics, while offloading the complexity of managing client-side API task queues and server-side R session lifecycles.

The basic programming model for working with RBroker is as follows:
1. Decide if the R Analytics tasks for your application should execute as:
  - Discrete tasks: authentication optional, grid resources allocated at runtime, results returned immediately, no persistence. Good for prototyping and public facing production deployments.
  - Pooled tasks: authentication required, grid resources pre-allocated, results returned immediately, optional persistence to repository. Good for enterprise production deployments, consistent runtime, high-throughput environments.
  - Background tasks: authentication required, grid resources allocated at runtime, results persisted for later retrieval. Good for periodic, scheduled or batch processing.
2. Use the RBrokerFactory to create an appropriate instance of RBroker.
3. Define the R Analytics tasks for your application as one or more RTask.
4. Submit your RTask to RBroker for execution.
5. Track the progress of your RTask using RTaskToken.
6. Integrate the results of your RTask found within RTaskResult.
This programming model can be further simplified for application developers by leveraging asynchronous callbacks. Simply register an RTaskListener with your RBroker instance and the RBroker will automatically notify your application when each RTask completes. This approach allows your application to skip step 5. above and scale effortlessly.

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`void`	`addBrokerListener(RBrokerListener brokerListener)` Register an asynchronous listener to receive callbacks on `RBroker` runtime statistics events or runtime errors.
`void`	`addTaskListener(RTaskListener taskListener)` Register an asynchronous listener to receive callbacks on `RTask` completion or failure events.
`RBrokerStatus`	`flush()` Flushes all pending `RTask` from queues maintained by `RBroker`.
`boolean`	`isConnected()` Indicates if current `RBroker` instance is still connected to the DeployR server.
`int`	`maxConcurrency()` Returns the task execution concurrency levels enforced for this instance of `RBroker`.
`com.revo.deployr.client.RUser`	`owner()` Returns a token indicating the owner of the current instance of `RBroker`.
`void`	`refresh(RBrokerConfig config)` Refresh configuration for `RBroker`.
`void`	`shutdown()` Release all client-side and server-side resources maintained by or on behalf of an instance of `RBroker`.
`void`	`simulateApp(RTaskAppSimulator appSimulator)` Launch an RTaskAppSimulator simulation.
`RBrokerStatus`	`status()` Returns status indicating current `RTask` activity on `RBroker`.
`RTaskToken`	`submit(RTask task)` Submit an `RTask` for execution under the control of `RBroker`.
`RTaskToken`	`submit(RTask task, boolean priority)` Submit a priority `RTask` for execution under the control of `RBroker`.

- Method Detail
  - refresh
```
void refresh(RBrokerConfig config)
      throws RBrokerException
```
    Refresh configuration for RBroker.
    
    Note, support for refresh is only available on the PooledTaskBroker runtime. In addition, only PoolCreationOptions are processed on this call. All other RBrokerConfig options are ignored.
    
    A refresh causes all workspace objects and directory files in the underlying R sessions within the pool to be cleared before new workspace objects and/or directory files are loaded per the new config options.
    Only an idle RBroker instance can be refreshed. An RBrokerException will be raised if this method is called when the instance of RBroker is currently busy with queued or executing RTask.
    
    Throws:
    
    RBrokerException
  - submit
```
RTaskToken submit(RTask task)
           throws RBrokerException
```
    Submit an RTask for execution under the control of RBroker.
    
    Throws:
    
    RBrokerException
  - submit
```
RTaskToken submit(RTask task,
                  boolean priority)
           throws RBrokerException
```
    Submit a priority RTask for execution under the control of RBroker.
    Priority tasks are automatically moved to the front of the queue, ahead of all standard tasks that are already pending execution by the broker.
    
    Throws:
    
    RBrokerException
  - addTaskListener
```
void addTaskListener(RTaskListener taskListener)
              throws RBrokerException
```
    Register an asynchronous listener to receive callbacks on RTask completion or failure events.
    
    Throws:
    
    RBrokerException
  - addBrokerListener
```
void addBrokerListener(RBrokerListener brokerListener)
                throws RBrokerException
```
    Register an asynchronous listener to receive callbacks on RBroker runtime statistics events or runtime errors.
    
    Throws:
    
    RBrokerException
  - simulateApp
```
void simulateApp(RTaskAppSimulator appSimulator)
```
    Launch an RTaskAppSimulator simulation. The RTask defined by your simulation will be automatically executed by the current instance of RBroker.
    Make sure to register your RTaskListener and RBrokerListener before starting your simulation in order to receive asynchronous callbacks in your application when RTask complete and/or to receive runtime summary statistics from RBroker as the simulation proceeds.
  - maxConcurrency
```
int maxConcurrency()
```
    Returns the task execution concurrency levels enforced for this instance of RBroker.
  - status
```
RBrokerStatus status()
```
    Returns status indicating current RTask activity on RBroker.
    
    This call can be used to determine if an RBroker instance is idle which can be particularly useful ahead calls to shutdown().
    
    The RBrokerStatus.pendingTasks and RBrokerStatus.executingTasks fields can be used by an application to estimate time remaining until RBroker reaches an idle state.
    The RBrokerStatus.isIdle field is provided for convenience for an application if individual pending and executing task counts are not relevant in shutdown() decisions.
  - flush
```
RBrokerStatus flush()
```
    Flushes all pending RTask from queues maintained by RBroker. Flushing RTask queues ensures that queued tasks will not be executed by RBroker.
  - isConnected
```
boolean isConnected()
```
    Indicates if current RBroker instance is still connected to the DeployR server. A connection may be lost for a number of reasons, for example, due to a droppeed network connection between client and server or if the DeployR server itself goes down.
  - shutdown
```
void shutdown()
```
    Release all client-side and server-side resources maintained by or on behalf of an instance of RBroker.
  - owner
```
com.revo.deployr.client.RUser owner()
```
    Returns a token indicating the owner of the current instance of RBroker.
    For anonymous RBroker instances, null is returned. For authenticated RBroker instances, an instance of com.revo.deployr.client.RUser is returned.

Interface RBroker

Method Summary

Method Detail

refresh

submit

submit

addTaskListener

addBrokerListener

simulateApp

maxConcurrency

status

flush

isConnected

shutdown

owner