service

Type Members

1. class AsyncHandlerGenerator[I, O] extends AnyRef

   So we need to take a type-parameterized request object, package it into a monomorphic case class to send to the worker, and have the handler that receives that object able to pattern match out the parameterized object, all without using reflection.

2. trait AsyncServiceClient[I, O] extends SharedClient[I, O]

3. class BasicServiceDelegator[C <: CodecDSL] extends DSLDelegator[C]

4. class BasicServiceHandler[C <: CodecDSL] extends ServiceServer[service.BasicServiceHandler.C.Input, service.BasicServiceHandler.C.Output] with DSLHandler[C]

5. trait Callback[+O] extends AnyRef

   A Callback is a Monad for doing in-thread non-blocking operations.

6. case class CallbackExec(cb: () ⇒ Unit, in: Option[FiniteDuration] = scala.None) extends Product with Serializable

7. trait CallbackExecution extends Actor with ActorLogging

8. class CallbackExecutionException extends Exception

   This exception is only thrown when there's a uncaught exception in the execution block of a Callback.

9. case class CallbackExecutor(context: ExecutionContext, executor: ActorRef) extends Product with Serializable

   A CallbackExecutor is an actor that mixes in the [CallbackExecution] trait to complete the execution of a [Callback] that has been converted from a Future.

10. trait ClientCodecProvider[C <: CodecDSL] extends AnyRef

11. case class ClientConfig(address: InetSocketAddress, requestTimeout: Duration, name: MetricAddress, pendingBufferSize: Int = 100, sentBufferSize: Int = 20, failFast: Boolean = false, connectionAttempts: PollingDuration = ...) extends Product with Serializable

    Configuration used to specify a Client's parameters

12. trait ClientLike[I, O, M[_]] extends AnyRef

    The ClientLike trait is intended to be an interface for anything that you can connect to and send messages.

13. class ClientOverloadedException extends ServiceClientException

    Thrown when the pending buffer is full

14. class ClientProxy extends Actor with ActorLogging with Stash

    This correctly routes messages to the right worker and handler

15. trait Codec[Output, Input] extends AnyRef

    A Codec is a stateful object for converting requests/responses to/from DataBuffers.

16. trait CodecDSL extends AnyRef

17. trait CodecProvider[C <: CodecDSL] extends AnyRef

    Provide a Codec as well as some convenience functions for usage within in a Service.

18. implicit final class Completable[O] extends AnyVal

19. case class Completion[+O](value: O, tags: TagMap = metrics.`package`.TagMap.Empty, onwrite: OnWriteAction = OnWriteAction.DoNothing) extends Product with Serializable

20. trait ConnectionContext[C <: CodecDSL] extends AnyRef

21. class ConnectionLostException extends ServiceClientException

    Thrown when a request is lost in transit

22. abstract class DSLDelegator[C <: CodecDSL] extends Delegator with ServiceContext[C]

23. trait DSLHandler[C <: CodecDSL] extends ServiceServer[service.DSLHandler.C.Input, service.DSLHandler.C.Output] with ConnectionContext[C]

24. class DataException extends ServiceClientException

    Thrown when there's some kind of data error

25. trait DefaultHandler extends CodecDSL

26. class Delayer extends Actor with ActorLogging

    This little actor is needed because apparently actors that are running in a pinned dispatcher AND are sending messages to themselves (like workers) cannot use the scheduler.

27. class DroppedReply extends Error

28. class LoadBalancingClient[I, O] extends LocalClient[I, O] with WorkerItem

    The LoadBalancingClient will evenly distribute requests across a set of clients.

29. class LoadBalancingClientException extends Exception

30. trait LocalClient[I, O] extends ClientLike[I, O, Callback]

31. case class MappedCallback[I, O](trigger: ((Try[I]) ⇒ Unit) ⇒ Unit, handler: (Try[I]) ⇒ Try[O]) extends Callback[O] with Product with Serializable

32. trait MessageDecoder[T] extends AnyRef

33. trait MessageEncoder[T] extends AnyRef

34. class NotConnectedException extends ServiceClientException

    Throw when a request is attempted while not connected

35. sealed trait OnWriteAction extends AnyRef

    NOTE - for now the meta field here will be mutable for simplicity and to avoid excessive object construction.

36. class PermutationGenerator[T] extends Iterator[List[T]]

    The PermutationGenerator creates permutations such that consecutive calls are guaranteed to cycle though all items as the first element.

37. class RequestBufferFullException extends Exception

38. class RequestTimeoutException extends ServiceClientException

    Returned when a request has been pending for too long

39. sealed trait Response[+O] extends AnyRef

40. class SendFailedException extends Exception

41. class ServiceClient[I, O] extends ClientConnectionHandler with ServiceClientLike[I, O]

    A ServiceClient is a non-blocking, synchronous interface that handles sending atomic commands on a connection and parsing their replies

42. class ServiceClientException extends Exception

43. trait ServiceClientLike[I, O] extends LocalClient[I, O]

44. class ServiceClientPool[I, O, T <: ServiceClient[I, O]] extends AnyRef

    A ClientPool is a simple container of open connections.

45. case class ServiceConfig(name: MetricAddress, requestTimeout: Duration, requestBufferSize: Int = 100, logErrors: Boolean = true) extends Product with Serializable

    Configuration class for a Service Server Connection Handler

46. trait ServiceContext[C <: CodecDSL] extends AnyRef

47. abstract class ServiceServer[I, O] extends ConnectionHandler

    The ServiceServer provides an interface and basic functionality to create a server that processes requests and returns responses over a codec.

48. trait SharedClient[I, O] extends ClientLike[I, O, Future]

49. class StaleClientException extends Exception

    This is thrown when a Client is manually disconnected, and subsequent attempt is made to reconnect.

50. class UnhandledRequestException extends Exception

51. case class UnmappedCallback[I](trigger: ((Try[I]) ⇒ Unit) ⇒ Unit) extends Callback[I] with Product with Serializable

    UnmappedCallback is essentially an optimization that avoids needing to create a MappedCallback with an identity function