Service

The Service object is an entry point into the the Service DSL which provide some convenience functions for quickly creating a Server serving responses to requests utilizing a Codec(ie: memcached, http, redis, etc).

One thing to always keep in mind is that code inside the Service.serve is placed inside a Delegator and ConnectionHandler, which means that it directly runs inside of a Worker and its SelectLoop. Be VERY mindful of the code that you place in here, as if there is any blocking code it will block the Worker. Not good.

An example with full typing in place to illustrate :

import colossus.protocols.http._  //imports an implicit codec

implicit val ioSystem : IOSystem = myBootStrappingFunction()

Service.serve[Http]("my-app", 9090) { context : ServiceContext[Http] =>

  //everything in this block happens on delegator initialization, which is on application startup.  One time only.

  context.handle { connection : ConnectionContext[Http] => {
      //This block is for connectionHandler initialization. Happens in the event loop.  Don't block.
      //Note, that a connection can handle multiple requests.
      connection.become {
        //this partial function is what "handles" a request.  Again.. don't block.
        case req @ Get on Text("test") => future(req.ok(someService.getDataFromStore()))
        case req @ Get on Text("path") => req.ok("path")
      }
    }
  }
}

Linear Supertypes

AnyRef, Any

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
final def asInstanceOf[T0]: T0

Definition Classes
Any
def become[T <: CodecDSL](name: String, port: Int, requestTimeout: Duration = 100.milliseconds)(handler: PartialHandler[T])(implicit system: IOSystem, provider: CodecProvider[T]): ServerRef

Start a simple, stateless service
Start a simple, stateless service
Unlike Service.serve, there is no room for per-worker or per-connection initialization. Useful when starting simple services or testing
T
the type of codec this service uses
name
Name of this Service
port
Port on which this Server will accept connections
system
The IOSystem to which this Server will belong
provider
CodecProvider
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

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

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

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def serve[T <: CodecDSL](name: String, port: Int, requestTimeout: Duration = 100.milliseconds)(handler: Initializer[T])(implicit system: IOSystem, provider: CodecProvider[T]): ServerRef

Quick-start a service, using default settings
Quick-start a service, using default settings
name
The name of the service
port
The port to bind the server to
def serve[T <: CodecDSL](serverSettings: ServerSettings, serviceConfig: ServiceConfig[Service.serve.T.Input, Service.serve.T.Output])(handler: Initializer[T])(implicit system: IOSystem, provider: CodecProvider[T]): ServerRef

Start a service with worker and connection initialization
Start a service with worker and connection initialization
The basic structure of a service using this method is:
```
Service.serve[Http]{ workerContext =>
  //worker initialization
  workerContext.handle { connectionContext =>
    //connection initialization
    connection.become {
      case ...
    }
  }
}
```
T
The codec to use, eg Http, Redis
serverSettings
Settings to provide the underlying server
serviceConfig
Config for the service
handler
The worker initializer to use for the service
returns
A ServerRef for the server.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
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( ... )

Related Doc: package service

object Service

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def become[T <: CodecDSL](name: String, port: Int, requestTimeout: Duration = 100.milliseconds)(handler: PartialHandler[T])(implicit system: IOSystem, provider: CodecProvider[T]): ServerRef

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def serve[T <: CodecDSL](name: String, port: Int, requestTimeout: Duration = 100.milliseconds)(handler: Initializer[T])(implicit system: IOSystem, provider: CodecProvider[T]): ServerRef

def serve[T <: CodecDSL](serverSettings: ServerSettings, serviceConfig: ServiceConfig[Service.serve.T.Input, Service.serve.T.Output])(handler: Initializer[T])(implicit system: IOSystem, provider: CodecProvider[T]): ServerRef

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from AnyRef

Inherited from Any

Ungrouped