package client3
- Alphabetic
- By Inheritance
- client3
- SttpApi
- UriInterpolator
- SttpExtensions
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Package Members
Type Members
- abstract class AbstractCurlBackend[F[_]] extends SttpBackend[F, Any]
- sealed trait BasicRequestBody extends RequestBody[Any]
- type BodySerializer[B] = (B) => BasicRequestBody
Provide an implicit value of this type to serialize arbitrary classes into a request body.
Provide an implicit value of this type to serialize arbitrary classes into a request body. Backends might also provide special logic for serializer instances which they define (e.g. to handle streaming).
- case class ByteArrayBody(b: Array[Byte], defaultContentType: MediaType = MediaType.ApplicationOctetStream) extends BasicRequestBody with Product with Serializable
- case class ByteBufferBody(b: ByteBuffer, defaultContentType: MediaType = MediaType.ApplicationOctetStream) extends BasicRequestBody with Product with Serializable
- case class ConditionalResponseAs[+T, R](condition: (ResponseMetadata) => Boolean, responseAs: ResponseAs[T, R]) extends Product with Serializable
- abstract class DelegateSttpBackend[F[_], +P] extends SttpBackend[F, P]
A base class for delegate backends, which includes delegating implementations for
close
andresponseMonad
, so that onlysend
needs to be defined. - case class DeserializationException[DE](body: String, error: DE)(implicit evidence$5: ShowError[DE]) extends ResponseException[Nothing, DE] with Product with Serializable
- class DigestAuthenticationBackend[F[_], P] extends DelegateSttpBackend[F, P]
- class EitherBackend[P] extends SttpBackend[[β$0$]Either[Throwable, β$0$], P]
A synchronous backend that safely wraps SttpBackend exceptions in
Either[Throwable, *]
'sA synchronous backend that safely wraps SttpBackend exceptions in
Either[Throwable, *]
's- P
TODO
- type Empty[X] = None.type
- case class FileBody(f: SttpFile, defaultContentType: MediaType = MediaType.ApplicationOctetStream) extends BasicRequestBody with Product with Serializable
- class FollowRedirectsBackend[F[_], P] extends DelegateSttpBackend[F, P]
- case class HttpError[HE](body: HE, statusCode: StatusCode) extends ResponseException[HE, Nothing] with Product with Serializable
- type Identity[X] = X
- case class InputStreamBody(b: InputStream, defaultContentType: MediaType = MediaType.ApplicationOctetStream) extends BasicRequestBody with Product with Serializable
- case class MappedResponseAs[T, T2, R](raw: ResponseAs[T, R], g: (T, ResponseMetadata) => T2, showAs: Option[String]) extends ResponseAs[T2, R] with Product with Serializable
- case class MultipartBody[R](parts: Seq[Part[RequestBody[R]]]) extends RequestBody[R] with Product with Serializable
- type PartialRequest[T, -R] = RequestT[Empty, T, R]
A RequestT without the method & uri specified (which cannot yet be sent).
- type Request[T, -R] = RequestT[Identity, T, R]
A RequestT with the method & uri specified.
A RequestT with the method & uri specified. Such a request can be sent.
- sealed trait RequestBody[-R] extends AnyRef
- case class RequestOptions(followRedirects: Boolean, readTimeout: Duration, maxRedirects: Int, redirectToGet: Boolean) extends Product with Serializable
- case class RequestT[U[_], T, -R](method: U[Method], uri: U[Uri], body: RequestBody[R], headers: Seq[Header], response: ResponseAs[T, R], options: RequestOptions, tags: Map[String, Any]) extends HasHeaders with RequestTExtensions[U, T, R] with Product with Serializable
Describes a HTTP request, along with a description of how the response body should be handled.
Describes a HTTP request, along with a description of how the response body should be handled.
The request can be sent using a SttpBackend, which provides a superset of the required capabilities.
- U
Specifies if the method & uri are specified. By default can be either: * Empty, which is a type constructor which always resolves to None. This type of request is aliased to PartialRequest: there's no method and uri specified, and the request cannot be sent. * Identity, which is an identity type constructor. This type of request is aliased to Request: the method and uri are specified, and the request can be sent.
- T
The target type, to which the response body should be read.
- R
The backend capabilities required by the request or response description. This might be
Any
(no requirements), Effect (the backend must support the given effect type), Streams (the ability to send and receive streaming bodies) or sttp.capabilities.WebSockets (the ability to handle websocket requests).- response
Description of how the response body should be handled. Needs to be specified upfront so that the response is always consumed and hence there are no requirements on client code to consume it. An exception to this are unsafe streaming and websocket responses, which need to be consumed/closed by the client.
- tags
Request-specific tags which can be used by backends for logging, metrics, etc. Not used by default.
- trait RequestTExtensions[U[_], T, -R] extends AnyRef
- class ResolveRelativeUrisBackend[F[_], +P] extends DelegateSttpBackend[F, P]
- case class Response[T](body: T, code: StatusCode, statusText: String, headers: Seq[Header], history: List[Response[Unit]], request: RequestMetadata) extends ResponseMetadata with Product with Serializable
- history
If redirects are followed, and there were redirects, contains responses for the intermediate requests. The first response (oldest) comes first.
- sealed trait ResponseAs[+T, -R] extends AnyRef
Describes how response body should be handled.
Describes how response body should be handled.
Apart from the basic cases (ignoring, reading as a byte array or file), response body descriptions can be mapped over, to support custom types. The mapping can take into account the ResponseMetadata, that is the headers and status code. Responses can also be handled depending on the response metadata. Finally, two response body descriptions can be combined (with some restrictions).
A number of
as[Type]
helper methods are available as part of SttpApi and when importingsttp.client3._
.- T
Target type as which the response will be read.
- R
The backend capabilities required by the response description. This might be
Any
(no requirements), Effect (the backend must support the given effect type), Streams (the ability to send and receive streaming bodies) or WebSockets (the ability to handle websocket requests).
- case class ResponseAsBoth[A, B, R](l: ResponseAs[A, R], r: ResponseAs[B, Any]) extends ResponseAs[(A, Option[B]), R] with Product with Serializable
- case class ResponseAsFile(output: SttpFile) extends ResponseAs[SttpFile, Any] with Product with Serializable
- case class ResponseAsFromMetadata[T, R](conditions: List[ConditionalResponseAs[T, R]], default: ResponseAs[T, R]) extends ResponseAs[T, R] with Product with Serializable
- case class ResponseAsStream[F[_], T, Stream, S] extends ResponseAs[T, Effect[F] with S] with Product with Serializable
- case class ResponseAsStreamUnsafe[BinaryStream, S] extends ResponseAs[BinaryStream, S] with Product with Serializable
- case class ResponseAsWebSocket[F[_], T](f: (WebSocket[F], ResponseMetadata) => F[T]) extends WebSocketResponseAs[T, Effect[F] with WebSockets] with Product with Serializable
- case class ResponseAsWebSocketStream[S, Pipe[_, _]](s: Streams[S], p: Pipe[Data[_], WebSocketFrame]) extends WebSocketResponseAs[Unit, S with WebSockets] with Product with Serializable
- case class ResponseAsWebSocketUnsafe[F[_]]() extends WebSocketResponseAs[WebSocket[F], Effect[F] with WebSockets] with Product with Serializable
- sealed abstract class ResponseException[+HE, +DE] extends Exception
- type RetryWhen = (Request[_, _], Either[Throwable, Response[_]]) => Boolean
- trait ShowError[-T] extends AnyRef
- class SpecifyAuthScheme[U[_], T, -R] extends AnyRef
- case class StreamBody[BinaryStream, S] extends RequestBody[S] with Product with Serializable
- case class StringBody(s: String, encoding: String, defaultContentType: MediaType = MediaType.TextPlain) extends BasicRequestBody with Product with Serializable
- trait SttpApi extends SttpExtensions with UriInterpolator
- trait SttpBackend[F[_], +P] extends AnyRef
A backend is used to send HTTP requests described by RequestT.
A backend is used to send HTTP requests described by RequestT. Backends might wrap Java or Scala HTTP clients, or other backends.
- F
The effect type used when returning responses. E.g. Identity for synchronous backends, scala.concurrent.Future for asynchronous backends.
- P
Capabilities supported by this backend, in addition to Effect. This might be
Any
(no special capabilities), Streams (the ability to send and receive streaming bodies) or WebSockets (the ability to handle websocket requests).
- Note
Backends should try to classify exceptions into one of the categories specified by SttpClientException. Other exceptions should be thrown unchanged.
- case class SttpBackendOptions(connectionTimeout: FiniteDuration, proxy: Option[Proxy]) extends Product with Serializable
- abstract class SttpClientException extends Exception
Known exceptions that might occur when using a backend.
Known exceptions that might occur when using a backend. Currently this covers:
- connect exceptions: when a connection (tcp socket) can't be established to the target host
- read exceptions: when a connection has been established, but there's any kind of problem receiving or handling the response (e.g. a broken socket or a deserialization error)
In general, it's safe to assume that the request hasn't been sent in case of connect exceptions. With read exceptions, the target host might or might have not received and processed the request.
The SttpBackend.send methods might also throw other exceptions, due to programming errors, bugs in the underlying implementations, bugs in sttp or an uncovered exception.
- trait SttpExtensions extends AnyRef
- case class TooManyRedirectsException(uri: Uri, redirects: Int) extends Exception with Product with Serializable
- class TryBackend[P] extends SttpBackend[Try, P]
A synchronous backend that safely wraps SttpBackend exceptions in
Try
'sA synchronous backend that safely wraps SttpBackend exceptions in
Try
's- P
TODO
- implicit class UriContext extends AnyRef
- Definition Classes
- UriInterpolator
- sealed trait WebSocketResponseAs[T, -R] extends ResponseAs[T, R]
Deprecated Type Members
- type DeserializationError[DE] = DeserializationException[DE]
- Annotations
- @deprecated
- Deprecated
(Since version 3.0.0) use DeserializationException
- type ResponseError[+HE, +DE] = ResponseException[HE, DE]
- Annotations
- @deprecated
- Deprecated
(Since version 3.0.0) use ResponseException
Value Members
- val DefaultReadTimeout: Duration
- Definition Classes
- SttpApi
- def asBoth[A, B](l: ResponseAs[A, Any], r: ResponseAs[B, Any]): ResponseAs[(A, B), Any]
Use both
l
andr
to read the response body.Use both
l
andr
to read the response body. Neither response specifications may use streaming or web sockets.- Definition Classes
- SttpApi
- def asBothOption[A, B, R](l: ResponseAs[A, R], r: ResponseAs[B, Any]): ResponseAs[(A, Option[B]), R]
Use
l
to read the response body.Use
l
to read the response body. If the raw body value which is used byl
is replayable (a file or byte array), also user
to read the response body. Otherwise ignorer
(if the raw body is a stream or a web socket).- Definition Classes
- SttpApi
- def asByteArray: ResponseAs[Either[String, Array[Byte]], Any]
- Definition Classes
- SttpApi
- def asByteArrayAlways: ResponseAs[Array[Byte], Any]
- Definition Classes
- SttpApi
- def asEither[A, B, R](onError: ResponseAs[A, R], onSuccess: ResponseAs[B, R]): ResponseAs[Either[A, B], R]
Uses the
onSuccess
response specification for successful responses (2xx), and theonError
specification otherwise.Uses the
onSuccess
response specification for successful responses (2xx), and theonError
specification otherwise.- Definition Classes
- SttpApi
- def asFile(file: File): ResponseAs[Either[String, File], Any]
- Definition Classes
- SttpExtensions
- def asFileAlways(file: File): ResponseAs[File, Any]
- Definition Classes
- SttpExtensions
- def asParams(charset: String): ResponseAs[Either[String, Seq[(String, String)]], Any]
Use the given charset by default, unless specified otherwise in the response headers.
Use the given charset by default, unless specified otherwise in the response headers.
- Definition Classes
- SttpApi
- def asParams: ResponseAs[Either[String, Seq[(String, String)]], Any]
Use the
utf-8
charset by default, unless specified otherwise in the response headers.Use the
utf-8
charset by default, unless specified otherwise in the response headers.- Definition Classes
- SttpApi
- def asParamsAlways(charset: String): ResponseAs[Seq[(String, String)], Any]
Use the given charset by default, unless specified otherwise in the response headers.
Use the given charset by default, unless specified otherwise in the response headers.
- Definition Classes
- SttpApi
- def asParamsAlways: ResponseAs[Seq[(String, String)], Any]
Use the
utf-8
charset by default, unless specified otherwise in the response headers.Use the
utf-8
charset by default, unless specified otherwise in the response headers.- Definition Classes
- SttpApi
- def asPath(path: Path): ResponseAs[Either[String, Path], Any]
- Definition Classes
- SttpExtensions
- def asPathAlways(path: Path): ResponseAs[Path, Any]
- Definition Classes
- SttpExtensions
- def asStream[F[_], T, S](s: Streams[S])(f: (BinaryStream) => F[T]): ResponseAs[Either[String, T], Effect[F] with S]
- Definition Classes
- SttpApi
- def asStreamAlways[F[_], T, S](s: Streams[S])(f: (BinaryStream) => F[T]): ResponseAs[T, Effect[F] with S]
- Definition Classes
- SttpApi
- def asStreamAlwaysUnsafe[S](s: Streams[S]): ResponseAs[BinaryStream, S]
- Definition Classes
- SttpApi
- def asStreamAlwaysWithMetadata[F[_], T, S](s: Streams[S])(f: (BinaryStream, ResponseMetadata) => F[T]): ResponseAs[T, Effect[F] with S]
- Definition Classes
- SttpApi
- def asStreamUnsafe[S](s: Streams[S]): ResponseAs[Either[String, BinaryStream], S]
- Definition Classes
- SttpApi
- def asStreamWithMetadata[F[_], T, S](s: Streams[S])(f: (BinaryStream, ResponseMetadata) => F[T]): ResponseAs[Either[String, T], Effect[F] with S]
- Definition Classes
- SttpApi
- def asString(charset: String): ResponseAs[Either[String, String], Any]
Use the given charset by default, unless specified otherwise in the response headers.
Use the given charset by default, unless specified otherwise in the response headers.
- Definition Classes
- SttpApi
- def asString: ResponseAs[Either[String, String], Any]
Use the
utf-8
charset by default, unless specified otherwise in the response headers.Use the
utf-8
charset by default, unless specified otherwise in the response headers.- Definition Classes
- SttpApi
- def asStringAlways(charset: String): ResponseAs[String, Any]
- Definition Classes
- SttpApi
- def asStringAlways: ResponseAs[String, Any]
Use the
utf-8
charset by default, unless specified otherwise in the response headers.Use the
utf-8
charset by default, unless specified otherwise in the response headers.- Definition Classes
- SttpApi
- def asWebSocket[F[_], T](f: (WebSocket[F]) => F[T]): ResponseAs[Either[String, T], Effect[F] with WebSockets]
- Definition Classes
- SttpApi
- def asWebSocketAlways[F[_], T](f: (WebSocket[F]) => F[T]): ResponseAs[T, Effect[F] with WebSockets]
- Definition Classes
- SttpApi
- def asWebSocketAlwaysUnsafe[F[_]]: ResponseAs[WebSocket[F], Effect[F] with WebSockets]
- Definition Classes
- SttpApi
- def asWebSocketAlwaysWithMetadata[F[_], T](f: (WebSocket[F], ResponseMetadata) => F[T]): ResponseAs[T, Effect[F] with WebSockets]
- Definition Classes
- SttpApi
- def asWebSocketEither[A, B, R](onError: ResponseAs[A, R], onSuccess: ResponseAs[B, R]): ResponseAs[Either[A, B], R]
Uses the
onSuccess
response specification for 101 responses (switching protocols), and theonError
specification otherwise.Uses the
onSuccess
response specification for 101 responses (switching protocols), and theonError
specification otherwise.- Definition Classes
- SttpApi
- def asWebSocketStream[S](s: Streams[S])(p: Pipe[Data[_], WebSocketFrame]): ResponseAs[Either[String, Unit], S with WebSockets]
- Definition Classes
- SttpApi
- def asWebSocketStreamAlways[S](s: Streams[S])(p: Pipe[Data[_], WebSocketFrame]): ResponseAs[Unit, S with WebSockets]
- Definition Classes
- SttpApi
- def asWebSocketUnsafe[F[_]]: ResponseAs[Either[String, WebSocket[F]], Effect[F] with WebSockets]
- Definition Classes
- SttpApi
- def asWebSocketWithMetadata[F[_], T](f: (WebSocket[F], ResponseMetadata) => F[T]): ResponseAs[Either[String, T], Effect[F] with WebSockets]
- Definition Classes
- SttpApi
- val basicRequest: RequestT[Empty, Either[String, String], Any]
A starting request, with the following modification comparing to
emptyRequest
:Accept-Encoding
is set togzip, deflate
(compression/decompression is handled automatically by the library).A starting request, with the following modification comparing to
emptyRequest
:Accept-Encoding
is set togzip, deflate
(compression/decompression is handled automatically by the library).Reads the response body as an
Either[String, String]
, whereLeft
is used if the status code is non-2xx, andRight
otherwise.- Definition Classes
- SttpApi
- val emptyRequest: RequestT[Empty, Either[String, String], Any]
An empty request with no headers.
An empty request with no headers.
Reads the response body as an
Either[String, String]
, whereLeft
is used if the status code is non-2xx, andRight
otherwise.- Definition Classes
- SttpApi
- def fromMetadata[T, R](default: ResponseAs[T, R], conditions: ConditionalResponseAs[T, R]*): ResponseAs[T, R]
- Definition Classes
- SttpApi
- def ignore: ResponseAs[Unit, Any]
- Definition Classes
- SttpApi
- def multipart[B](name: String, b: B)(implicit arg0: BodySerializer[B]): Part[BasicRequestBody]
Content type will be set to
application/octet-stream
, can be overridden later using thecontentType
method.Content type will be set to
application/octet-stream
, can be overridden later using thecontentType
method.- Definition Classes
- SttpApi
- def multipart(name: String, fs: Seq[(String, String)], encoding: String): Part[BasicRequestBody]
Encodes the given parameters as form data.
Encodes the given parameters as form data.
Content type will be set to
application/x-www-form-urlencoded
, can be overridden later using thecontentType
method.- Definition Classes
- SttpApi
- def multipart(name: String, fs: Seq[(String, String)]): Part[BasicRequestBody]
Encodes the given parameters as form data using
utf-8
.Encodes the given parameters as form data using
utf-8
.Content type will be set to
application/x-www-form-urlencoded
, can be overridden later using thecontentType
method.- Definition Classes
- SttpApi
- def multipart(name: String, fs: Map[String, String], encoding: String): Part[BasicRequestBody]
Encodes the given parameters as form data.
Encodes the given parameters as form data.
Content type will be set to
application/x-www-form-urlencoded
, can be overridden later using thecontentType
method.- Definition Classes
- SttpApi
- def multipart(name: String, fs: Map[String, String]): Part[BasicRequestBody]
Encodes the given parameters as form data using
utf-8
.Encodes the given parameters as form data using
utf-8
.Content type will be set to
application/x-www-form-urlencoded
, can be overridden later using thecontentType
method.- Definition Classes
- SttpApi
- def multipart(name: String, data: InputStream): Part[BasicRequestBody]
Content type will be set to
application/octet-stream
, can be overridden later using thecontentType
method.Content type will be set to
application/octet-stream
, can be overridden later using thecontentType
method.- Definition Classes
- SttpApi
- def multipart(name: String, data: ByteBuffer): Part[BasicRequestBody]
Content type will be set to
application/octet-stream
, can be overridden later using thecontentType
method.Content type will be set to
application/octet-stream
, can be overridden later using thecontentType
method.- Definition Classes
- SttpApi
- def multipart(name: String, data: Array[Byte]): Part[BasicRequestBody]
Content type will be set to
application/octet-stream
, can be overridden later using thecontentType
method.Content type will be set to
application/octet-stream
, can be overridden later using thecontentType
method.- Definition Classes
- SttpApi
- def multipart(name: String, data: String, encoding: String): Part[BasicRequestBody]
Content type will be set to
text/plain
with given encoding, can be overridden later using thecontentType
method.Content type will be set to
text/plain
with given encoding, can be overridden later using thecontentType
method.- Definition Classes
- SttpApi
- def multipart(name: String, data: String): Part[BasicRequestBody]
Content type will be set to
text/plain
withutf-8
encoding, can be overridden later using thecontentType
method.Content type will be set to
text/plain
withutf-8
encoding, can be overridden later using thecontentType
method.- Definition Classes
- SttpApi
- def multipartFile(name: String, data: Path): Part[BasicRequestBody]
Content type will be set to
application/octet-stream
, can be overridden later using thecontentType
method.Content type will be set to
application/octet-stream
, can be overridden later using thecontentType
method.File name will be set to the name of the file.
- Definition Classes
- SttpExtensions
- def multipartFile(name: String, data: File): Part[BasicRequestBody]
Content type will be set to
application/octet-stream
, can be overridden later using thecontentType
method.Content type will be set to
application/octet-stream
, can be overridden later using thecontentType
method.File name will be set to the name of the file.
- Definition Classes
- SttpExtensions
- def multipartStream[S](s: Streams[S])(name: String, b: BinaryStream): Part[RequestBody[S]]
Content type will be set to
application/octet-stream
, can be overridden later using thecontentType
method.Content type will be set to
application/octet-stream
, can be overridden later using thecontentType
method.- Definition Classes
- SttpApi
- val quickRequest: RequestT[Empty, String, Any]
A starting request which always reads the response body as a string, regardless of the status code.
A starting request which always reads the response body as a string, regardless of the status code.
- Definition Classes
- SttpApi
- object AbstractCurlBackend
- object CurlBackend
- object CurlTryBackend
- object DigestAuthenticationBackend
- object FileHelpers
- object FollowRedirectsBackend
- case object IgnoreResponse extends ResponseAs[Unit, Any] with Product with Serializable
- case object NoBody extends RequestBody[Any] with Product with Serializable
- object RequestBody
- object RequestT extends Serializable
- object ResolveRelativeUrisBackend
- object Response extends Serializable
- object ResponseAs
- case object ResponseAsByteArray extends ResponseAs[Array[Byte], Any] with Product with Serializable
- object ResponseAsStream extends Serializable
- object ResponseAsStreamUnsafe extends Serializable
- object RetryWhen
- object ShowError
- object StreamBody extends Serializable
- object SttpBackendOptions extends Serializable
- object SttpClientException extends Serializable
- object quick extends SttpApi