WebSocketHandshakeEvent

Event fired when performing a web socket handshake to upgrade a HTTP connection to a web socket connection.

Socko requires this event be processed in your route and NOT passed to actors. The only action that needs to be taken is to call event.authorize().

val routes = Routes({
  case event @ Path("/snoop/websocket/") => event match {
    case event: WebSocketHandshakeEvent => {
      event.authorize()
    }
    case event: WebSocketFrameEvent => {
      myActorSystem.actorOf(Props[MyWebSocketFrameProcessor], name) ! event
    }
  }
})

Calling event.authorize() authorizes Socko to perform all the necessary handshaking. If not called, Socko will reject the handshake and web sockets processing will be aborted.

event.authorize() is a security measure to ensure that upgrades to web socket connections is only performed at explicit routes.

nettyHttpRequest: HTTP request associated with the upgrade to web sockets connection
config: Processing configuration

Linear Supertypes

Serializable, Serializable, Product, Equals, HttpEvent, SockoEvent, AnyRef, Any

Instance Constructors

new WebSocketHandshakeEvent(context: ChannelHandlerContext, nettyHttpRequest: FullHttpRequest, config: HttpEventConfig)

nettyHttpRequest
HTTP request associated with the upgrade to web sockets connection
config
Processing configuration

Value Members

final def !=(arg0: AnyRef): Boolean

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

Definition Classes
Any
final def ##(): Int

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

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

Definition Classes
Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def authorize(subprotocols: String = "", maxFrameSize: Int = 102400, onComplete: Option[(String) ⇒ Unit] = None, onClose: Option[(String) ⇒ Unit] = None): Unit

Authorize this web socket handshake to proceed
Authorize this web socket handshake to proceed
maxFrameSize
Maximum size of web socket frames. Defaults to 100K.
onComplete
Optional callback executed when the handshake is successfully completed. You can use this callback to register the web socket client as being ready to receive data.
onClose
Optional callback executed when the websocket is closed. The closed web socket id is passed to method
def authorizedSubprotocols: String

Comma separated list of supported protocols.
Comma separated list of supported protocols. e.g. chat, stomp
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
val config: HttpEventConfig

Processing configuration
Processing configuration

Definition Classes
WebSocketHandshakeEvent → HttpEvent
val context: ChannelHandlerContext

Netty channel associated with this request
Netty channel associated with this request

Definition Classes
WebSocketHandshakeEvent → SockoEvent
val createdOn: Date

Timestamp when this event was fired
Timestamp when this event was fired

Definition Classes
SockoEvent
def duration(): Long

Number of milliseconds from the time when this context was created
Number of milliseconds from the time when this context was created

Definition Classes
SockoEvent
val endPoint: EndPoint

HTTP end point
HTTP end point

Definition Classes
WebSocketHandshakeEvent → SockoEvent
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
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 isAuthorized: Boolean

Indicates if this web socket handshake is authorized or not
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
lazy val items: Map[String, Any]

Store of items that can be used to pass data from route to processor and between processors.
Store of items that can be used to pass data from route to processor and between processors.
This map is not synchronized and not thread-safe. In most cases, we expect this cache to be used by a single thread - hence a standard map is faster.
If you do need to use a thread safe map, from your route, instance and store a ConcurrentHashMap as an item in this cache.

Definition Classes
SockoEvent
def maxFrameSize: Int

Maximum size of frames for this web socket connection in bytes.
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
val nettyHttpRequest: FullHttpRequest

HTTP request associated with the upgrade to web sockets connection
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def onClose: Option[(String) ⇒ Unit]

Callback for when the web socket is closed
def onComplete: Option[(String) ⇒ Unit]

Callback for when the handshake as completed
val request: CurrentHttpRequestMessage

Incoming HTTP request
val response: Null

Always s set to null because no response is available for handshakes.
Always s set to null because no response is available for handshakes. Let the handshaker do the work for you.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
var username: Option[String]

Username of the authenticated user.
Username of the authenticated user. You need to set this for it to appear in the web logs.
Socko does not make assumptions on your authentication method. You do it and set this username to let us know.

Definition Classes
SockoEvent
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( ... )
val webSocketId: String

Unique ID for this web socket connection
Unique ID for this web socket connection
With Netty 5, we can use ChannelId. However, this is not supported in Netty 4 so we'll have to use a combination of the UUID and the object hash code.
def writeWebLog(responseStatusCode: Int, responseSize: Long): Unit

Adds an entry to the web log
Adds an entry to the web log
responseStatusCode
HTTP status code
responseSize
length of response content in bytes

Definition Classes
WebSocketHandshakeEvent → HttpEvent

case class WebSocketHandshakeEvent(context: ChannelHandlerContext, nettyHttpRequest: FullHttpRequest, config: HttpEventConfig) extends SockoEvent with HttpEvent with Product with Serializable

Instance Constructors

new WebSocketHandshakeEvent(context: ChannelHandlerContext, nettyHttpRequest: FullHttpRequest, config: HttpEventConfig)

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def authorize(subprotocols: String = "", maxFrameSize: Int = 102400, onComplete: Option[(String) ⇒ Unit] = None, onClose: Option[(String) ⇒ Unit] = None): Unit

def authorizedSubprotocols: String

def clone(): AnyRef

val config: HttpEventConfig

val context: ChannelHandlerContext

val createdOn: Date

def duration(): Long

val endPoint: EndPoint

final def eq(arg0: AnyRef): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def isAuthorized: Boolean

final def isInstanceOf[T0]: Boolean

lazy val items: Map[String, Any]

def maxFrameSize: Int

final def ne(arg0: AnyRef): Boolean

val nettyHttpRequest: FullHttpRequest

final def notify(): Unit

final def notifyAll(): Unit

def onClose: Option[(String) ⇒ Unit]

def onComplete: Option[(String) ⇒ Unit]

val request: CurrentHttpRequestMessage

val response: Null

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

var username: Option[String]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

val webSocketId: String

def writeWebLog(responseStatusCode: Int, responseSize: Long): Unit

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from HttpEvent

Inherited from SockoEvent

Inherited from AnyRef

Inherited from Any

Ungrouped