Quiver.Conn behaviour (quiver v0.2.0)

Behaviour for HTTP connection implementations.

Connections are protocol-specific data structs (HTTP/1, HTTP/2) that serialize requests and parse responses over a transport.

All response fragments are tagged with a request reference for multiplexing support. HTTP/1 uses a single ref per request.

Summary

Types

body()

headers()

method()

response_fragment()

t()

Callbacks

cancel(conn, ref)

close(conn)

connect(uri, opts)

max_concurrent_streams(conn)

open?(conn)

open_request(conn, method, path, headers, body)

open_request_count(conn)

request(conn, method, path, headers, body)

stream(conn, message)

Types

body()

@type body() :: iodata() | nil | {:stream, Enumerable.t()}

headers()

@type headers() :: [{String.t(), String.t()}]

method()

@type method() ::
  :get | :head | :post | :put | :delete | :patch | :options | :trace | :connect

response_fragment()

@type response_fragment() ::
  {:status, reference(), non_neg_integer()}
  | {:headers, reference(), headers()}
  | {:data, reference(), binary()}
  | {:done, reference()}
  | {:error, reference(), term()}

t()

@type t() :: struct()

Callbacks

cancel(conn, ref)

(optional)

@callback cancel(conn :: t(), ref :: reference()) :: {:ok, t()} | {:error, t(), term()}

close(conn)

@callback close(conn :: t()) :: {:ok, t()}

connect(uri, opts)

@callback connect(uri :: URI.t(), opts :: keyword()) :: {:ok, t()} | {:error, term()}

max_concurrent_streams(conn)

(optional)

@callback max_concurrent_streams(conn :: t()) :: non_neg_integer()

open?(conn)

@callback open?(conn :: t()) :: boolean()

open_request(conn, method, path, headers, body)

(optional)

@callback open_request(
  conn :: t(),
  method(),
  path :: String.t(),
  headers(),
  body :: body()
) :: {:ok, t(), reference()} | {:error, t(), term()}

open_request_count(conn)

(optional)

@callback open_request_count(conn :: t()) :: non_neg_integer()

request(conn, method, path, headers, body)

@callback request(conn :: t(), method(), path :: String.t(), headers(), body :: body()) ::
  {:ok, t(), Quiver.Response.t()} | {:error, t(), term()}

stream(conn, message)

@callback stream(conn :: t(), message :: term()) ::
  {:ok, t(), [response_fragment()]} | {:error, t(), term()} | :unknown