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))

ActiveState

</>

Mapping to the {active, _} option

pub type ActiveState {
  Once
  Passive
  Count(Int)
  Active
}

Constructors

```
Once
```
```
Passive
```
```
Count(Int)
```
```
Active
```

Channel

</>

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

HandlerFunc

</>

pub type HandlerFunc(data) =
  fn(BitString, LoopState(data)) -> actor.Next(LoopState(data))

HandlerMessage

</>

All message types that the handler will receive, or that you can send to the handler process

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

Constructors

```
Close
```
```
Ready
```
```
ReceiveMessage(BitString)
```
```
Tcp(socket: Port, data: BitString)
```
```
TcpClosed(Nil)
```

ListenSocket

</>

pub opaque type ListenSocket

LoopFn

</>

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

LoopState

</>

pub type LoopState(data) {
  LoopState(
    socket: Socket,
    sender: Sender(HandlerMessage),
    data: data,
  )
}

Constructors

LoopState(
  socket: Socket,
  sender: Sender(HandlerMessage),
  data: data,
)

Socket

</>

pub opaque type Socket

SocketMode

</>

Mode for the socket. Currently list is not supported

pub type SocketMode {
  Binary
}

Constructors

```
Binary
```

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)
  ActiveMode(ActiveState)
  Mode(SocketMode)
}

Constructors

```
Backlog(Int)
```
```
Nodelay(Bool)
```
```
Linger(#(Bool, Int))
```
```
SendTimeout(Int)
```
```
SendTimeoutClose(Bool)
```
```
Reuseaddr(Bool)
```
```
ActiveMode(ActiveState)
```
```
Mode(SocketMode)
```

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_shutdown

</>

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

echo_loop

</>

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

handler

</>

pub fn handler(handler func: fn(BitString, LoopState(a)) ->
    Next(LoopState(a))) -> fn(HandlerMessage, LoopState(a)) ->
  Next(LoopState(a))

This helper will generate a TCP handler that will call your handler function with the BitString data in the packet as well as the LoopState, with any associated state data you are maintaining

listen

</>

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

Start listening over TCP on a port with the given options

receive

</>

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

receive_timeout

</>

pub external fn receive_timeout(
  socket: Socket,
  length: Int,
  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: BitBuilder,
) -> Result(Nil, SocketReason)

set_opts

</>

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

Update the optons 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, initial_data: a, loop_fn: fn(
    HandlerMessage,
    LoopState(a),
  ) -> Next(LoopState(a))) -> 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,
    LoopState(a),
  ) -> Next(LoopState(a)), initial_data: a, pool_count: Int) -> Result(
  Sender(Message),
  StartError,
)

Starts a pool of acceptors of size pool_count.

Runs loop_fn on ever message received

start_handler

</>

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

Starts an actor for the TCP connection