http

Types

Body

pub type Body {
  Initial(BitArray)
  Stream(
    selector: process.Selector(#(BitArray, Bool)),
    data: BitArray,
    end: Bool,
    attempts: Int,
    send_headers: fn(Int, List(#(String, String))) -> Nil,
    send_data: fn(BitArray) -> Result(Nil, Nil),
    consume_data: fn(Int) -> Nil,
    close_after: fn(process.Pid) -> Nil,
  )
}

Constructors

```
Initial(BitArray)
```

Stream(
  selector: process.Selector(#(BitArray, Bool)),
  data: BitArray,
  end: Bool,
  attempts: Int,
  send_headers: fn(Int, List(#(String, String))) -> Nil,
  send_data: fn(BitArray) -> Result(Nil, Nil),
  consume_data: fn(Int) -> Nil,
  close_after: fn(process.Pid) -> Nil,
)

Chunk

</>

pub type Chunk {
  Chunk(data: BitArray, buffer: buffer.Buffer)
  Complete
}

Constructors

Chunk(data: BitArray, buffer: buffer.Buffer)

```
Complete
```

Connection

</>

pub type Connection {
  Connection(
    body: Body,
    socket: socket.Socket,
    transport: transport.Transport,
    factory_name: process.Name(
      factory_supervisor.Message(
        fn() -> Result(
          actor.Started(process.Pid),
          actor.StartError,
        ),
        process.Pid,
      ),
    ),
    read_timeout: Int,
  )
}

Constructors

Connection(
  body: Body,
  socket: socket.Socket,
  transport: transport.Transport,
  factory_name: process.Name(
    factory_supervisor.Message(
      fn() -> Result(actor.Started(process.Pid), actor.StartError),
      process.Pid,
    ),
  ),
  read_timeout: Int,
)

DecodeError

</>

pub type DecodeError {
  MalformedRequest
  InvalidMethod
  InvalidPath
  UnknownHeader
  UnknownMethod
  InvalidBody
  ExcessBody
  DiscardPacket
  NoHostHeader
  InvalidHttpVersion
}

Constructors

```
MalformedRequest
```
```
InvalidMethod
```
```
InvalidPath
```
```
UnknownHeader
```
```
UnknownMethod
```
```
InvalidBody
```
```
ExcessBody
```
```
DiscardPacket
```
```
NoHostHeader
```
```
InvalidHttpVersion
```

DecodedPacket

</>

pub type DecodedPacket {
  BinaryData(HttpPacket, BitArray)
  EndOfHeaders(BitArray)
  MoreData(option.Option(Int))
  Http2Upgrade(BitArray)
}

Constructors

```
BinaryData(HttpPacket, BitArray)
```
```
EndOfHeaders(BitArray)
```
```
MoreData(option.Option(Int))
```
```
Http2Upgrade(BitArray)
```

Handler

</>

pub type Handler =
  fn(request.Request(Connection)) -> response.Response(
    ResponseData,
  )

HttpPacket

</>

pub type HttpPacket {
  HttpRequest(dynamic.Dynamic, HttpUri, #(Int, Int))
  HttpHeader(Int, atom.Atom, BitArray, BitArray)
}

Constructors

HttpRequest(dynamic.Dynamic, HttpUri, #(Int, Int))

HttpHeader(Int, atom.Atom, BitArray, BitArray)

HttpUri

</>

pub type HttpUri {
  AbsPath(BitArray)
}

Constructors

```
AbsPath(BitArray)
```

HttpVersion

</>

pub type HttpVersion {
  Http1
  Http11
}

Constructors

```
Http1
```
```
Http11
```

PacketType

</>

pub type PacketType {
  Http
  HttphBin
  HttpBin
}

Constructors

```
Http
```
```
HttphBin
```
```
HttpBin
```

ParsedRequest

</>

pub type ParsedRequest {
  Http1Request(
    request: request.Request(Connection),
    version: HttpVersion,
  )
  Upgrade(BitArray)
}

Constructors

Http1Request(
  request: request.Request(Connection),
  version: HttpVersion,
)

```
Upgrade(BitArray)
```

ResponseData

</>

pub type ResponseData {
  Websocket
  Bytes(bytes_tree.BytesTree)
  Chunked
  File(descriptor: file.FileDescriptor, offset: Int, length: Int)
  ServerSentEvents
}

Constructors

```
Websocket
```
```
Bytes(bytes_tree.BytesTree)
```
```
Chunked
```

File(descriptor: file.FileDescriptor, offset: Int, length: Int)

```
ServerSentEvents
```

ShaHash

</>

pub type ShaHash {
  Sha
}

Constructors

```
Sha
```

Values

add_content_length

</>

pub fn add_content_length(
  when when: Bool,
  length length: Int,
) -> fn(response.Response(any)) -> response.Response(any)

add_date_header

</>

pub fn add_date_header(
  resp: response.Response(any),
) -> response.Response(any)

add_default_headers

</>

pub fn add_default_headers(
  resp: response.Response(bytes_tree.BytesTree),
  is_head_response: Bool,
) -> response.Response(bytes_tree.BytesTree)

base64_encode

</>

pub fn base64_encode(data data: String) -> String

connection_close

</>

pub fn connection_close(
  resp: response.Response(any),
) -> response.Response(any)

crypto_hash

</>

pub fn crypto_hash(
  hash hash: ShaHash,
  data data: String,
) -> String

from_header

</>

pub fn from_header(value: BitArray) -> String

handle_continue

</>

pub fn handle_continue(
  req: request.Request(Connection),
) -> Result(Nil, DecodeError)

keep_alive

</>

pub fn keep_alive(
  resp: response.Response(any),
) -> response.Response(any)

maybe_keep_alive

</>

pub fn maybe_keep_alive(
  resp: response.Response(any),
) -> response.Response(any)

parse_chunk

</>

pub fn parse_chunk(string: BitArray) -> Chunk

parse_headers

</>

pub fn parse_headers(
  bs: BitArray,
  socket: socket.Socket,
  transport: transport.Transport,
  headers: dict.Dict(String, String),
  read_timeout: Int,
) -> Result(#(dict.Dict(String, String), BitArray), DecodeError)

parse_request

</>

pub fn parse_request(
  bs: BitArray,
  conn: Connection,
) -> Result(ParsedRequest, DecodeError)

Turns the TCP message into an HTTP request

read_body

</>

pub fn read_body(
  req: request.Request(Connection),
  max_body_limit: Int,
) -> Result(request.Request(BitArray), DecodeError)

read_data

</>

pub fn read_data(
  socket: socket.Socket,
  transport: transport.Transport,
  buffer: buffer.Buffer,
  error: DecodeError,
  read_timeout: Int,
) -> Result(BitArray, DecodeError)

upgrade

</>

pub fn upgrade(
  socket: socket.Socket,
  transport: transport.Transport,
  extensions: List(String),
  req: request.Request(Connection),
) -> Result(Nil, Nil)

upgrade_socket

</>

pub fn upgrade_socket(
  req: request.Request(Connection),
  extensions: List(String),
) -> Result(
  response.Response(bytes_tree.BytesTree),
  request.Request(Connection),
)

version_to_string

</>

pub fn version_to_string(version: HttpVersion) -> String