Client

An HTTP client.

val eventuallyContent = client(Get("/hello")).flatMap { response =>
  response.readAs[String]
}

An HTTP client is a Service function. It handles HTTP requests and eventually returns HTTP responses.

A client maintains several TCP connections to the remote server. These connections are used to send requests and are blocked until the corresponding response has been received. If no connection is available when a new request comes, it waits for connectionTimeout time for one connection to become available.

It is important that the user code completly consumes the response content stream, so the connection is freed for the next request. That's why it is better to use the run operation if possible since this one automatically drains the request upon return.

If the request to execute does not specify an Host header, it will be automatically added and set to the value of the client host.

Linear Supertypes

(Request) ⇒ Future[Response], AnyRef, Any

Abstract Value Members

abstract def connectionTimeout: FiniteDuration

The maximum amount of time a request will wait to obtain an HTTP connection.
implicit abstract def executor: ExecutionContext

The ExecutionContext that will be used to run the user code.
abstract def host: String

The host this client is connected to.
abstract def maxConnections: Int

The maximum number of TCP connections maintained with the remote server.
abstract def options: ClientOptions

The client options such as the number of IO thread used.
abstract def port: Int

The TCP port this client is connected to.
abstract def scheme: String

The scheme used by this client (either HTTP or HTTPS if connected in SSL).
abstract def ssl: Configuration

The SSL configuration used by the client.
The SSL configuration used by the client. Must be provided if the server certificate is not recognized by default.

Concrete 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 andThen[A](g: (Future[Response]) ⇒ A): (Request) ⇒ A

Definition Classes
Function1
Annotations
@unspecialized()
def apply(request: Request, followRedirects: Boolean, timeout: FiniteDuration = FiniteDuration(30, "seconds")): Future[Response]

Send a request to the server and eventually give back the response.
Send a request to the server and eventually give back the response.
request
the HTTP request to be sent to the server.
followRedirects
if true follow the intermediate HTTP redirects.
timeout
maximum amount of time allowed to retrieve the response.
returns
eventually the HTTP response.
def apply(request: Request): Future[Response]

Send a request to the server and eventually give back the response.
Send a request to the server and eventually give back the response.
request
the HTTP request to be sent to the server.
returns
eventually the HTTP response.

Definition Classes
Client → Function1
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def compose[A](g: (A) ⇒ Request): (A) ⇒ Future[Response]

Definition Classes
Function1
Annotations
@unspecialized()
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
def isClosed: Boolean

Check if this client is already closed (ie.
Check if this client is already closed (ie. it does not accept any more requests).
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 openedConnections: Int

The number of TCP connections currently opened with the remote server.
def run[A](request: Request, followRedirects: Boolean = true, timeout: FiniteDuration = FiniteDuration(30, "seconds"))(thunk: (Response) ⇒ Future[A] = ...): Future[A]

Send this request to the server, eventually run the given function and return the result.
Send this request to the server, eventually run the given function and return the result. This operation ensures that the response content stream is fully read even if the provided user code do not consume it. The response is drained as soon as the f function returns.
request
the HTTP request to be sent to the server.
followRedirects
if true follow the intermediate HTTP redirects. Default to true.
timeout
maximum amount of time allowed to retrieve the response and extract the return value.
thunk
a function that eventually receive the response and transform it to a value of type A.
returns
eventually a value of type A.
def runAndStop[A](thunk: (Client) ⇒ Future[A]): Future[A]

Run the given function and close the client.
Run the given function and close the client.
thunk
a function that take a client and eventually return a value of type A.
returns
eventually a value of type A.
def stop(): Future[Unit]

Stop the client and kill all current and waiting requests.
Stop the client and kill all current and waiting requests.
returns
a Future resolved as soon as the client is shutdown.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
Client → Function1 → 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 Docs: object Client | package http

trait Client extends Service

Abstract Value Members

abstract def connectionTimeout: FiniteDuration

implicit abstract def executor: ExecutionContext

abstract def host: String

abstract def maxConnections: Int

abstract def options: ClientOptions

abstract def port: Int

abstract def scheme: String

abstract def ssl: Configuration

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def andThen[A](g: (Future[Response]) ⇒ A): (Request) ⇒ A

def apply(request: Request, followRedirects: Boolean, timeout: FiniteDuration = FiniteDuration(30, "seconds")): Future[Response]

def apply(request: Request): Future[Response]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def compose[A](g: (A) ⇒ Request): (A) ⇒ Future[Response]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

def isClosed: Boolean

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def openedConnections: Int

def run[A](request: Request, followRedirects: Boolean = true, timeout: FiniteDuration = FiniteDuration(30, "seconds"))(thunk: (Response) ⇒ Future[A] = ...): Future[A]

def runAndStop[A](thunk: (Client) ⇒ Future[A]): Future[A]

def stop(): Future[Unit]

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 (Request) ⇒ Future[Response]

Inherited from AnyRef

Inherited from Any

Ungrouped