glisten/tcp

Types

Acceptor

pub type Acceptor {
  AcceptConnection(ListenSocket)
}

Constructors

```
AcceptConnection(ListenSocket)
```

AcceptorError

pub type AcceptorError {
  AcceptError
  HandlerError
  ControlError
}

Constructors

```
AcceptError
```
```
HandlerError
```
```
ControlError
```

AcceptorState

pub type AcceptorState {
  AcceptorState(sender: Sender(Acceptor), socket: Option(Socket))
}

Constructors

AcceptorState(sender: Sender(Acceptor), socket: Option(Socket))

Channel

pub type Channel =
  #(Socket, Receiver(Acceptor))

HandlerMessage

pub type HandlerMessage {
  ReceiveMessage(Charlist)
  Tcp(socket: Port, data: Charlist)
  TcpClosed(Nil)
}

Constructors

```
ReceiveMessage(Charlist)
```
```
Tcp(socket: Port, data: Charlist)
```
```
TcpClosed(Nil)
```

ListenSocket

pub opaque type ListenSocket

LoopFn

pub type LoopFn =
  fn(HandlerMessage, Socket) -> actor.Next(Socket)

Socket

pub opaque type Socket

SocketReason

pub type SocketReason {
  Closed
  Timeout
}

Constructors

```
Closed
```
```
Timeout
```

TcpOption

Options for the TCP socket

pub type TcpOption {
  Backlog(Int)
  Nodelay(Bool)
  Linger(#(Bool, Int))
  SendTimeout(Int)
  SendTimeoutClose(Bool)
  Reuseaddr(Bool)
  Active(Dynamic)
  Binary
}

Constructors

```
Backlog(Int)
```
```
Nodelay(Bool)
```
```
Linger(#(Bool, Int))
```
```
SendTimeout(Int)
```
```
SendTimeoutClose(Bool)
```
```
Reuseaddr(Bool)
```
```
Active(Dynamic)
```
```
Binary
```

Functions

accept

pub external fn accept(
  socket: ListenSocket,
) -> Result(Socket, SocketReason)

accept_timeout

pub external fn accept_timeout(
  socket: ListenSocket,
  timeout: Int,
) -> Result(Socket, SocketReason)

close

pub external fn close(socket: Socket) -> Atom

do_listen_tcp

pub external fn do_listen_tcp(
  port: Int,
  options: List(TcpOption),
) -> Result(ListenSocket, SocketReason)

do_receive

pub external fn do_receive(
  socket: Socket,
  length: Int,
) -> Result(BitString, SocketReason)

do_shutdown

pub external fn do_shutdown(socket: Socket, write: Atom) -> Nil

echo_loop

pub fn echo_loop(msg: HandlerMessage, state: AcceptorState) -> Next(
  AcceptorState,
)

listen

pub fn listen(port: Int, options: List(TcpOption)) -> Result(
  ListenSocket,
  SocketReason,
)

Start listening over TCP on a port with the given options

merge_with_default_options

pub fn merge_with_default_options(options: List(TcpOption)) -> List(
  TcpOption,
)

receive

pub fn receive(socket: Socket) -> Result(BitString, SocketReason)

receive_timeout

pub fn receive_timeout(socket: Socket, timeout: Int) -> Result(
  BitString,
  SocketReason,
)

receiver_to_iterator

pub fn receiver_to_iterator(receiver: Receiver(a)) -> Iterator(a)

send

pub external fn send(
  socket: Socket,
  packet: Charlist,
) -> Result(Nil, SocketReason)

set_opts

pub external fn set_opts(
  socket: Socket,
  opts: List(TcpOption),
) -> Result(Nil, Nil)

Update the options for a socket (mutates the socket)

shutdown

pub fn shutdown(socket: Socket) -> Nil

socket_info

pub external fn socket_info(socket: Socket) -> Map(a, b)

start_acceptor

pub fn start_acceptor(socket: ListenSocket, loop_fn: fn(
    HandlerMessage,
    Socket,
  ) -> Next(Socket)) -> Result(Sender(Acceptor), StartError)

Worker process that handles accepting connections and starts a new process which receives the messages from the socket

start_acceptor_pool

pub fn start_acceptor_pool(listener_socket: ListenSocket, handler: fn(
    HandlerMessage,
    Socket,
  ) -> Next(Socket), pool_count: Int) -> Result(Nil, Nil)

Starts a pool of acceptors of size pool_count.

Runs loop_fn on ever message received

start_handler

pub fn start_handler(socket: Socket, loop: fn(
    HandlerMessage,
    Socket,
  ) -> Next(Socket)) -> Result(Sender(HandlerMessage), StartError)

Starts an actor for the TCP connection