DynamicWorkerRoutes

Instance Constructors

new DynamicWorkerRoutes(exchange: Exchange, defaultSubscription: WorkSubscription, defaultInitialRequest: Int)(implicit mat: Materializer)

Type Members

class OnWork[T] extends AnyRef

Captures the 'handler' logic for a subscription.
Captures the 'handler' logic for a subscription.

Attributes
protected

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def addHandler[T](onReq: (WorkContext[T]) ⇒ Unit)(implicit subscription: WorkSubscription = defaultSubscription, initialRequest: Int = defaultInitialRequest, fromRequest: FromRequestUnmarshaller[T]): Future[RequestWorkAck]

The main body for a handler ...
The main body for a handler ... registers a function ('onReq') which does some work.
Instead of a thinking of a generic computation as a function from A => B, This exposes the function as WorkContext[A] => ResponseEntity
The WorkContext exposes a handle onto the exchange (so the computation can request more work) and access details about the work sent to it
T
the request input type
onReq
the compute functions
subscription
the subscription to use when asking for work for this computation
initialRequest
how many work items to initially ask for
returns
a future of the 'request work' ack
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
val defaultInitialRequest: Int
val defaultSubscription: WorkSubscription
implicit val ec: ExecutionContextExecutor
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
val exchange: Exchange
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def find(workerName: String): Option[OnWork[_]]

Attributes
protected
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def handleWorkRoute: Route
def health: Route
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def listSubscriptions: Route
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def routes: Route

returns
the REST route
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def updateHandler[T](path: String)(onReq: (WorkContext[T]) ⇒ Unit)(fromRequest: FromRequestUnmarshaller[T]): Boolean

Replace the handler logic for the handler at the given path
Replace the handler logic for the handler at the given path
T
the handler body type
path
the relative path snippet for the handler to replace
onReq
the new handler logic
fromRequest
the unmarshaller to use
returns
true if a handler was previously registered at the given path (and thus replaced)
def usingSubscription(f: (WorkSubscription) ⇒ WorkSubscription): WithSubscriptionWord

Syntactic sugar to allow users to:
Syntactic sugar to allow users to:
```
val routes : WorkerRoutes = ...
routes.usingSubscription(XYZ).addHandler( ctxt => ... )
```
This is really only needed when a single worker has multiple handlers (i.e. work routes).
The implicit parameter list to addHandler() takes a WorkSubscription, which defaults to one provided from the configuration.
So, without the syntactic sugar, subsequent handlers would either need to set up another subscription in implicit scope or explicitly provide the curried implicit paramter, something akin to:
```
workRoute.addHandler[SomeCaseClass] { ctxt =>
  ...
}(workRoute.defaultSubscription.withPath("myNewHandler"))
```
f
a function which modifies the default subscription (or completely ignores it)
returns
A DSL-specific class which expects 'addHandler' to be called on it
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def withSubscription(s: WorkSubscription): WithSubscriptionWord

Like 'usingSubscription', this function provides a DSL for adding a handler.
Like 'usingSubscription', this function provides a DSL for adding a handler.
s
the work subscription used for the handler
returns
A DSL-specific class which expects 'addHandler' to be called on it
var workerByPath: Map[String, OnWork[_]]

Attributes
protected
def workerPaths: Set[String]

returns
the registered worker paths
def workerRoutes: Route

Related Docs: object DynamicWorkerRoutes | package worker

case class DynamicWorkerRoutes(exchange: Exchange, defaultSubscription: WorkSubscription, defaultInitialRequest: Int)(implicit mat: Materializer) extends Product with Serializable

Instance Constructors

new DynamicWorkerRoutes(exchange: Exchange, defaultSubscription: WorkSubscription, defaultInitialRequest: Int)(implicit mat: Materializer)

Type Members

class OnWork[T] extends AnyRef

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def addHandler[T](onReq: (WorkContext[T]) ⇒ Unit)(implicit subscription: WorkSubscription = defaultSubscription, initialRequest: Int = defaultInitialRequest, fromRequest: FromRequestUnmarshaller[T]): Future[RequestWorkAck]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

val defaultInitialRequest: Int

val defaultSubscription: WorkSubscription

implicit val ec: ExecutionContextExecutor

final def eq(arg0: AnyRef): Boolean

val exchange: Exchange

def finalize(): Unit

def find(workerName: String): Option[OnWork[_]]

final def getClass(): Class[_]

def handleWorkRoute: Route

def health: Route

final def isInstanceOf[T0]: Boolean

def listSubscriptions: Route

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def routes: Route

final def synchronized[T0](arg0: ⇒ T0): T0

def updateHandler[T](path: String)(onReq: (WorkContext[T]) ⇒ Unit)(fromRequest: FromRequestUnmarshaller[T]): Boolean

def usingSubscription(f: (WorkSubscription) ⇒ WorkSubscription): WithSubscriptionWord

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def withSubscription(s: WorkSubscription): WithSubscriptionWord

var workerByPath: Map[String, OnWork[_]]

def workerPaths: Set[String]

def workerRoutes: Route

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from AnyRef

Inherited from Any

Ungrouped