HTTP.WebTransport (http_web_transport v0.10.0)

View Source

Browser-like WebTransport client API for Elixir.

This module implements the public API shape and lifecycle management for WebTransport sessions. Browser-compatible network interoperability requires a backend that speaks WebTransport over HTTP/3; the default backend is currently a placeholder that reports :quic_backend_unavailable.

Summary

Types

congestion_control()
reliability()
state()
t()

Functions

await_closed(transport, timeout \\ :infinity)
await_draining(transport, timeout \\ :infinity)
await_ready(transport, timeout \\ :infinity)
close(transport)
close(transport, options)
closed(web_transport)
congestion_control(transport)
create_bidirectional_stream(transport, options \\ [])
create_send_group(transport)
create_unidirectional_stream(transport, options \\ [])
datagrams(transport)
draining(web_transport)
get_stats(transport)
incoming_bidirectional_streams(transport)
incoming_unidirectional_streams(transport)
new(url, init \\ [])
protocol(transport)
ready(web_transport)
reliability(transport)
response_headers(transport)
state(transport)
supports_reliable_only?()
url(web_transport)

Types

congestion_control()

@type congestion_control() :: :default | :throughput | :low_latency

reliability()

@type reliability() :: String.t()

state()

@type state() :: :connecting | :connected | :draining | :closed | :failed

t()

@type t() :: %HTTP.WebTransport{
  pid: pid() | nil,
  ref: reference() | nil,
  url: String.t() | nil
}

Functions

await_closed(transport, timeout \\ :infinity)

@spec await_closed(t(), timeout()) ::
  {:ok, HTTP.WebTransport.CloseInfo.t()} | {:error, term()}

await_draining(transport, timeout \\ :infinity)

@spec await_draining(t(), timeout()) :: :ok | {:error, term()}

await_ready(transport, timeout \\ :infinity)

@spec await_ready(t(), timeout()) :: :ok | {:error, term()}

close(transport)

@spec close(t()) :: :ok | {:error, term()}

close(transport, options)

@spec close(t(), keyword() | map()) :: :ok | {:error, term()}

closed(web_transport)

@spec closed(t()) :: HTTP.WebTransport.Promise.t()

congestion_control(transport)

@spec congestion_control(t()) :: congestion_control()

create_bidirectional_stream(transport, options \\ [])

@spec create_bidirectional_stream(t(), keyword() | map()) ::
  {:ok, HTTP.WebTransport.BidirectionalStream.t()} | {:error, term()}

create_send_group(transport)

@spec create_send_group(t()) :: HTTP.WebTransport.SendGroup.t()

create_unidirectional_stream(transport, options \\ [])

@spec create_unidirectional_stream(t(), keyword() | map()) ::
  {:ok, HTTP.WebTransport.SendStream.t()} | {:error, term()}

datagrams(transport)

@spec datagrams(t()) :: HTTP.WebTransport.DatagramDuplexStream.t()

draining(web_transport)

@spec draining(t()) :: HTTP.WebTransport.Promise.t()

get_stats(transport)

@spec get_stats(t()) :: {:ok, HTTP.WebTransport.Stats.t()} | {:error, term()}

incoming_bidirectional_streams(transport)

@spec incoming_bidirectional_streams(t()) :: HTTP.WebTransport.StreamQueue.t()

incoming_unidirectional_streams(transport)

@spec incoming_unidirectional_streams(t()) :: HTTP.WebTransport.StreamQueue.t()

new(url, init \\ [])

@spec new(String.t() | URI.t(), keyword() | map()) :: t() | {:error, term()}

protocol(transport)

@spec protocol(t()) :: String.t()

ready(web_transport)

@spec ready(t()) :: HTTP.WebTransport.Promise.t()

reliability(transport)

@spec reliability(t()) :: reliability()

response_headers(transport)

@spec response_headers(t()) :: [{String.t(), String.t()}] | nil

state(transport)

@spec state(t()) :: state()

supports_reliable_only?()

@spec supports_reliable_only?() :: false

url(web_transport)

@spec url(t()) :: String.t() | nil