Packages

  • package root
    Definition Classes
    root
  • package scamper

    At the core Scamper is HttpMessage, which is a trait that defines the fundamental characteristics of an HTTP message.

    HTTP Messages

    At the core Scamper is HttpMessage, which is a trait that defines the fundamental characteristics of an HTTP message. HttpRequest and HttpResponse extend the specification to define characteristics specific to their respective message types.

    An HttpRequest is created using one of the factory methods defined in its companion object. Or you can start with a RequestMethod and use builder methods to further define the request.

    import scamper.Header
    import scamper.Implicits.stringToUri
    import scamper.RequestMethods.GET
    
    val request = GET("/motd").withHeaders(
      Header("Host", "localhost:8080"),
      Header("Accept", "text/plain")
    )
    
    printf("Request Method: %s%n", request.method)
    printf("Target URI: %s%n", request.target)
    
    request.headers.foreach(println)
    
    val host: Option[String] = request.getHeaderValue("Host")

    An HttpResponse is created using one of the factory methods defined in its companion object. Or you can start with a ResponseStatus and use builder methods to further define the response.

    import scamper.{ BodyParsers, Header }
    import scamper.Implicits.stringToEntity
    import scamper.ResponseStatuses.Ok
    
    val response = Ok("There is an answer.").withHeaders(
      Header("Content-Type", "text/plain"),
      Header("Connection", "close")
    )
    
    printf("Status Code: %s%n", response.status.code)
    printf("Reason Phrase: %s%n", response.status.reason)
    
    response.headers.foreach(println)
    
    val contentType: Option[String] = response.getHeaderValue("Content-Type")
    
    implicit val parser = BodyParsers.text()
    
    printf("Body: %s%n", response.as[String])
    Definition Classes
    root
  • package auth

    Provides access to authethentication types and headers.

    Provides access to authethentication types and headers.

    Challenges and Credentials

    When working with authentication, a Challenge is presented in the response, and Credentials in the request. Each of these has an assigned scheme, which is associated with either a token or a set of parameters.

    import scamper.Implicits.stringToUri
    import scamper.RequestMethods.GET
    import scamper.ResponseStatuses.Unauthorized
    import scamper.auth.{ Authorization, Challenge, Credentials, WwwAuthenticate }
    
    // Present response challenge (scheme and parameters)
    val challenge = Challenge("Bearer", "realm" -> "developer")
    val res = Unauthorized().withWwwAuthenticate(challenge)
    
    // Present request credentials (scheme and token)
    val credentials = Credentials("Bearer", "QWxsIEFjY2VzcyEhIQo=")
    val req = GET("/dev/projects").withAuthorization(credentials)
    Basic Authentication

    There are subclasses defined for Basic authentication: BasicChallenge and BasicCredentials.

    import scamper.Implicits.stringToUri
    import scamper.RequestMethods.GET
    import scamper.ResponseStatuses.Unauthorized
    import scamper.auth.{ Authorization, BasicChallenge, BasicCredentials, WwwAuthenticate }
    
    // Provide realm and optional parameters
    val challenge = BasicChallenge("admin", "title" -> "Admin Console")
    val res = Unauthorized().withWwwAuthenticate(challenge)
    
    // Provide user and password
    val credentials = BasicCredentials("sa", "l3tm31n")
    val req = GET("/admin/users").withAuthorization(credentials)

    In addition, there are methods for Basic authentication defined in the header classes.

    import scamper.Implicits.stringToUri
    import scamper.RequestMethods.GET
    import scamper.ResponseStatuses.Unauthorized
    import scamper.auth.{ Authorization, WwwAuthenticate }
    
    // Provide realm and optional parameters
    val res = Unauthorized().withBasic("admin", "title" -> "Admin Console")
    
    // Access basic auth in response
    printf(s"Realm: %s%n", res.basic.realm)
    printf(s"Title: %s%n", res.basic.params("title"))
    
    // Provide user and password
    val req = GET("/admin/users").withBasic("sa", "l3tm3m1n")
    
    // Access basic auth in request
    printf(s"User: %s%n", req.basic.user)
    printf(s"Password: %s%n", req.basic.password)
    Bearer Authentication

    There are subclasses defined for Bearer authentication: BearerChallenge and BearerCredentials. And, similar to Basic, there are Bearer-specific methods available in the header classes.

    import scamper.Implicits.stringToUri
    import scamper.RequestMethods.GET
    import scamper.ResponseStatuses.Unauthorized
    import scamper.auth.{ Authorization, WwwAuthenticate }
    
    // Provide challenge parameters
    val res = Unauthorized().withBearer(
      "scope" -> "user profile",
      "error" -> "invalid_token",
      "error_description" -> "Expired access token"
    )
    
    // Print optional realm parameter
    res.bearer.realm.foreach(println)
    
    // Print scope from space-delimited parameter
    val scope: Seq[String] = res.bearer.scope
    scope.foreach(println)
    
    // Print error parameters
    res.bearer.error.foreach(println)
    res.bearer.errorDescription.foreach(println)
    res.bearer.errorUri.foreach(println)
    
    // Test for error conditions
    println(res.bearer.isInvalidToken)
    println(res.bearer.isInvalidRequest)
    println(res.bearer.isInsufficientScope)
    
    // Create request with Bearer token
    val req = GET("/users").withBearer("R290IDUgb24gaXQhCg==")
    Definition Classes
    scamper
  • package client

    Provides HTTP client implementation.

    Provides HTTP client implementation.

    Using HTTP Client

    The HttpClient object can be used to send a request and handle the response.

    import scamper.BodyParsers
    import scamper.Implicits.stringToUri
    import scamper.RequestMethods.GET
    import scamper.client.HttpClient
    
    implicit val parser = BodyParsers.text()
    
    def getMessageOfTheDay(): Either[Int, String] = {
      val req = GET("localhost:8080/motd")
    
      // Send request and handle response
      HttpClient.send(req) { res =>
        res.status.isSuccessful match {
          case true  => Right(res.as[String])
          case false => Left(res.status.code)
        }
      }
    }

    Note the request must be created with an absolute URI to make effective use of the client.

    Creating HTTP Client

    When using the HttpClient object as the client, it creates an instance of HttpClient for one-time usage. If you plan to send multiple requests, you can create and maintain a reference to an instance, and use it as the client. With that, you also get access to methods corresponding to the standard HTTP request methods.

    import scamper.BodyParsers
    import scamper.Implicits.stringToUri
    import scamper.client.HttpClient
    
    implicit val parser = BodyParsers.text()
    
    // Create HttpClient instance
    val client = HttpClient(bufferSize = 4096, readTimeout = 3000)
    
    def getMessageOfTheDay(): Either[Int, String] = {
      // Use client instance
      client.get("http://localhost:8080/motd") { res =>
        res.status.isSuccessful match {
          case true  => Right(res.as[String])
          case false => Left(res.status.code)
        }
      }
    }

    And if the client is declared as an implicit value, you can make use of send() on the request itself.

    import scamper.BodyParsers
    import scamper.Implicits.stringToUri
    import scamper.RequestMethods.GET
    import scamper.client.HttpClient
    import scamper.client.Implicits.ClientHttpRequestType // Adds send method to request
    import scamper.headers.{ Accept, AcceptLanguage }
    import scamper.types.Implicits.{ stringToMediaRange, stringToLanguageRange }
    
    implicit val client = HttpClient(bufferSize = 8192, readTimeout = 1000)
    implicit val parser = BodyParsers.text(4096)
    
    GET("http://localhost:8080/motd")
      .withAccept("text/plain")
      .withAcceptLanguage("en-US; q=0.6", "fr-CA; q=0.4")
      .send(res => println(res.as[String])) // Send request and print response
    Definition Classes
    scamper
  • package cookies

    Provides specialized access to message cookies.

    Provides specialized access to message cookies.

    Request Cookies

    In HttpRequest, cookies are stringed together in the Cookie header. You can access them using the extension methods provided by RequestCookies, with each cookie represented as PlainCookie.

    import scamper.Implicits.stringToUri
    import scamper.RequestMethods.GET
    import scamper.cookies.{ PlainCookie, RequestCookies }
    
    // Build request with cookies
    val req = GET("https://localhost:8080/motd").withCookies(
      PlainCookie("ID", "bG9zCg"), PlainCookie("Region", "SE-US")
    )
    
    // Access and print all cookies
    req.cookies.foreach(println)
    
    // Get cookies by name
    val id: Option[PlainCookie] = req.getCookie("ID")
    val region: Option[PlainCookie] = req.getCookie("Region")
    
    // Get cookie values by name
    assert(req.getCookieValue("ID").contains("bG9zCg"))
    assert(req.getCookieValue("Region").contains("SE-US"))
    Response Cookies

    In HttpResponse, the cookies are a collection of Set-Cookie header values. Specialized access is provided by ResponseCookies, with each cookie represented as SetCookie.

    import scamper.Implicits.stringToEntity
    import scamper.ResponseStatuses.Ok
    import scamper.cookies.{ ResponseCookies, SetCookie }
    
    // Build response with cookies
    val res = Ok("There is an answer.").withCookies(
      SetCookie("ID", "bG9zCg", path = Some("/motd"), secure = true),
      SetCookie("Region", "SE-US")
    )
    
    // Access and print all cookies
    res.cookies.foreach(println)
    
    // Get cookies by name
    val id: Option[SetCookie] = res.getCookie("ID")
    val region: Option[SetCookie] = res.getCookie("Region")
    
    // Get attributes of ID cookie
    val path: String = id.flatMap(_.path).getOrElse("/")
    val secure: Boolean = id.map(_.secure).getOrElse(false)
    
    // Get cookie values by name
    assert(res.getCookieValue("ID").contains("bG9zCg"))
    assert(res.getCookieValue("Region").contains("SE-US"))
    Definition Classes
    scamper
  • package headers

    Provides specialized access to message headers.

    Provides specialized access to message headers.

    Using Header Classes

    Specialized header access is provided by type classes. Some headers are available to both requests and responses, and others are available only to a specific message type. This behavior is driven by the HTTP specification.

    import scamper.Implicits.stringToUri
    import scamper.RequestMethods.GET
    import scamper.headers.{ Accept, Host }
    import scamper.types.Implicits.stringToMediaRange
    
    // Build request using 'Host' and 'Accept' headers
    val req = GET("/motd").withHost("localhost:8080").withAccept("text/plain")
    
    // Access and print header values
    printf("Host: %s%n", req.host)
    printf("Accept: %s%n", req.accept.head)
    Definition Classes
    scamper
  • package logging

    Provides logging facilities.

    Provides logging facilities.

    Definition Classes
    scamper
  • package server

    Provides HTTP server implementation.

    Provides HTTP server implementation.

    Building HTTP Server

    To build a server, you begin with ServerApplication. This is a mutable structure to which you apply changes to configure the server. Once the desired settings are applied, you invoke one of several methods to create the server.

    import java.io.File
    import scamper.BodyParsers
    import scamper.Implicits.{ stringToEntity, inputStreamToEntity }
    import scamper.ResponseStatuses.{ NotFound, Ok }
    import scamper.headers.TransferEncoding
    import scamper.server.HttpServer
    import scamper.server.Implicits.ServerHttpRequestType
    import scamper.types.Implicits.stringToTransferCoding
    
    // Get server application
    val app = HttpServer.app()
    
    // Add request handler to log all requests
    app.request { req =>
      println(req.startLine)
      req
    }
    
    // Add request handler to specific request method and path
    app.get("/about") { req => Ok("This server is powered by Scamper.") }
    
    // Add request handler using path parameter
    app.put("/data/:id") { req =>
      def update(id: Int, data: String): Boolean = ???
    
      implicit val parser = BodyParsers.text()
    
      // Get path parameter
      val id = req.params.getInt("id")
    
      update(id, req.as[String]) match {
        case true  => Ok()
        case false => NotFound()
      }
    }
    
    // Serve static files
    app.files("/main", new File("/path/to/public"))
    
    // Tell server to compress response
    app.response { res =>
      res.withTransferEncoding("gzip", "chunked")
    }
    
    // Create server
    val server = app.create(8080)
    
    printf("Host: %s%n", server.host)
    printf("Port: %d%n", server.port)
    
    Thread.sleep(60 * 1000)
    
    // Close server when done
    server.close()
    Definition Classes
    scamper
  • package types

    Defines standardized types for header classes in scamper.headers.

    Defines standardized types for header classes in scamper.headers.

    import scamper.Implicits.{ stringToEntity, stringToUri }
    import scamper.RequestMethods.GET
    import scamper.ResponseStatuses.Ok
    import scamper.headers.{ Accept, ContentType, TransferEncoding }
    import scamper.types.{ MediaRange, MediaType, TransferCoding }
    
    val json = MediaRange("application", "json", 0.9f)
    val html = MediaRange.parse("text/html; q=0.1")
    
    val req = GET("/motd").withAccept(json, html)
    
    val text = MediaType.parse("text/plain")
    val gzip = TransferCoding("gzip")
    
    val res = Ok("There is an answer.").withContentType(text).withTransferEncoding(gzip)

    Using values defined in Implicits, properly formatted strings can be implicitly converted to standardized types.

    import scamper.Implicits.{ stringToEntity, stringToUri }
    import scamper.RequestMethods.GET
    import scamper.ResponseStatuses.Ok
    import scamper.headers.{ Accept, ContentType, TransferEncoding }
    import scamper.types.Implicits._
    
    val req = GET("/motd").withAccept("application/json; q=0.9", "text/html; q=0.1")
    
    val res = Ok("There is an answer.").withContentType("text/plain").withTransferEncoding("gzip")
    Definition Classes
    scamper
  • BodyDecoding
  • BodyParser
  • BodyParsers
  • Entity
  • EntityTooLarge
  • FilePart
  • Header
  • HeaderNotFound
  • HttpException
  • HttpMessage
  • HttpRequest
  • HttpResponse
  • HttpVersion
  • Implicits
  • MessageBuilder
  • Multipart
  • Part
  • QueryString
  • ReadLimitExceeded
  • RequestLine
  • RequestMethod
  • RequestMethods
  • ResponseStatus
  • ResponseStatuses
  • StartLine
  • StatusLine
  • TextPart

trait HttpResponse extends HttpMessage with MessageBuilder[HttpResponse]

HTTP response

See also

HttpRequest

Linear Supertypes
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. HttpResponse
  2. MessageBuilder
  3. HttpMessage
  4. AnyRef
  5. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Type Members

  1. type LineType = StatusLine

    Type of start line used in message

    Type of start line used in message

    Definition Classes
    HttpResponseHttpMessage

Abstract Value Members

  1. abstract def addHeaders(headers: Header*): HttpResponse

    Creates message with additional headers.

    Creates message with additional headers.

    headers

    additional message headers

    returns

    new message

    Definition Classes
    MessageBuilder
  2. abstract def attributes: Map[String, Any]

    Gets message attributes.

    Gets message attributes.

    Attributes are arbitrary values associated with message and are not part of transmitted message.

    Definition Classes
    HttpMessage
  3. abstract def body: Entity

    Gets message body.

    Gets message body.

    Definition Classes
    HttpMessage
  4. abstract def headers: Seq[Header]

    Gets message headers.

    Gets message headers.

    Definition Classes
    HttpMessage
  5. abstract def removeAttribute(name: String): HttpResponse

    Creates message excluding attribute with given name.

    Creates message excluding attribute with given name.

    name

    attribute name

    returns

    new message

    Definition Classes
    MessageBuilder
  6. abstract def removeHeaders(names: String*): HttpResponse

    Creates message excluding headers with given field names.

    Creates message excluding headers with given field names.

    names

    header field names

    returns

    new message

    Definition Classes
    MessageBuilder
  7. abstract def startLine: LineType

    Gets message start line.

    Gets message start line.

    Definition Classes
    HttpMessage
  8. abstract def withAttribute(attribute: (String, Any)): HttpResponse

    Creates message with supplied attribute, replacing existing value, if any.

    Creates message with supplied attribute, replacing existing value, if any.

    attribute

    name/value pair

    returns

    new message

    Definition Classes
    MessageBuilder
  9. abstract def withAttributes(attributes: (String, Any)*): HttpResponse

    Creates message with supplied attributes.

    Creates message with supplied attributes. All previous attributes are removed.

    attributes

    message attributes

    returns

    new message

    Definition Classes
    MessageBuilder
  10. abstract def withBody(body: Entity): HttpResponse

    Creates message with supplied body.

    Creates message with supplied body.

    body

    message body

    returns

    new message

    Definition Classes
    MessageBuilder
  11. abstract def withHeader(header: Header): HttpResponse

    Creates message with supplied header.

    Creates message with supplied header. All previous headers with same field name are removed.

    header

    message header

    returns

    new message

    Definition Classes
    MessageBuilder
  12. abstract def withHeaders(headers: Header*): HttpResponse

    Creates message with supplied headers.

    Creates message with supplied headers. All previous headers are removed.

    headers

    message headers

    returns

    new message

    Definition Classes
    MessageBuilder
  13. abstract def withStartLine(line: LineType): HttpResponse

    Creates message with supplied start line.

    Creates message with supplied start line.

    returns

    new message

    Definition Classes
    MessageBuilder
  14. abstract def withStatus(status: ResponseStatus): HttpResponse

    Creates response with new response status.

    Creates response with new response status.

    returns

    new response

  15. abstract def withVersion(version: HttpVersion): HttpResponse

    Creates response with new HTTP version.

    Creates response with new HTTP version.

    returns

    new response

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. def as[T](implicit parser: BodyParser[T]): T

    Parses message body as defined type.

    Parses message body as defined type.

    Definition Classes
    HttpMessage
  5. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  6. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  7. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  8. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  9. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  10. def getAttribute[T](name: String): Option[T]

    Gets value of attribute with given name.

    Gets value of attribute with given name.

    name

    attribute name

    Definition Classes
    HttpMessage
  11. def getAttributeOrElse[T](name: String, default: => T): T

    Gets value of attribute with given name, or returns default if attribute not present.

    Gets value of attribute with given name, or returns default if attribute not present.

    name

    attribute name

    default

    default value

    Definition Classes
    HttpMessage
  12. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  13. def getHeader(name: String): Option[Header]

    Gets first header with given name.

    Gets first header with given name.

    Definition Classes
    HttpMessage
  14. def getHeaderOrElse(name: String, default: => Header): Header

    Gets first header with given name, or returns default if header not present.

    Gets first header with given name, or returns default if header not present.

    Definition Classes
    HttpMessage
  15. def getHeaderValue(name: String): Option[String]

    Gets value of first header with given name.

    Gets value of first header with given name.

    Definition Classes
    HttpMessage
  16. def getHeaderValueOrElse(name: String, default: => String): String

    Gets value of first header with given name, or returns default if header not present.

    Gets value of first header with given name, or returns default if header not present.

    Definition Classes
    HttpMessage
  17. def getHeaderValues(name: String): Seq[String]

    Gets value of all headers with given name.

    Gets value of all headers with given name.

    Definition Classes
    HttpMessage
  18. def getHeaders(name: String): Seq[Header]

    Gets all headers with given name.

    Gets all headers with given name.

    Definition Classes
    HttpMessage
  19. def hasHeader(name: String): Boolean

    Tests whether header with given name is present.

    Tests whether header with given name is present.

    Definition Classes
    HttpMessage
  20. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  21. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  22. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  23. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  24. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  25. def status: ResponseStatus

    Gets response status.

  26. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  27. def toString(): String
    Definition Classes
    AnyRef → Any
  28. def version: HttpVersion

    Gets HTTP version.

    Gets HTTP version.

    Definition Classes
    HttpMessage
  29. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  30. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  31. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()

Inherited from HttpMessage

Inherited from AnyRef

Inherited from Any

Ungrouped