glisten/acceptor

Types

AcceptorError

pub type AcceptorError {
  AcceptError
  HandlerError
  ControlError
}

Constructors

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

AcceptorMessage

</>

pub type AcceptorMessage {
  AcceptConnection(ListenSocket)
}

Constructors

```
AcceptConnection(ListenSocket)
```

AcceptorState

</>

pub type AcceptorState {
  AcceptorState(
    sender: Subject(AcceptorMessage),
    socket: Option(Socket),
    transport: Transport,
  )
}

Constructors

AcceptorState(
  sender: Subject(AcceptorMessage),
  socket: Option(Socket),
  transport: Transport,
)

Pool

</>

pub type Pool(data) {
  Pool(
    listener_socket: ListenSocket,
    handler: LoopFn(data),
    initial_data: data,
    pool_count: Int,
    on_init: Option(fn(Subject(HandlerMessage)) -> Nil),
    on_close: Option(fn(Subject(HandlerMessage)) -> Nil),
    transport: Transport,
  )
}

Constructors

Pool(
  listener_socket: ListenSocket,
  handler: LoopFn(data),
  initial_data: data,
  pool_count: Int,
  on_init: Option(fn(Subject(HandlerMessage)) -> Nil),
  on_close: Option(fn(Subject(HandlerMessage)) -> Nil),
  transport: Transport,
)

Functions

new_pool

</>

pub fn new_pool(handler: fn(HandlerMessage, LoopState(Nil)) ->
    Next(LoopState(Nil))) -> fn(ListenSocket) -> Pool(Nil)

Initialize acceptor pool where each handler has no state

new_pool_with_data

</>

pub fn new_pool_with_data(handler: fn(
    HandlerMessage,
    LoopState(a),
  ) -> Next(LoopState(a)), initial_data: a) -> fn(ListenSocket) ->
  Pool(a)

Initialize an acceptor pool where each handler holds some state

over_ssl

</>

pub fn over_ssl(make_pool: fn(ListenSocket) -> Pool(a)) -> fn(
  ListenSocket,
) -> Pool(a)

Use SSL for the underlying socket.

start

</>

pub fn start(pool: Pool(a)) -> Result(
  Subject(AcceptorMessage),
  StartError,
)

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

start_pool

</>

pub fn start_pool(pool: Pool(a)) -> Result(
  Subject(Message),
  StartError,
)

Starts a pool of acceptors of size pool_count.

Runs loop_fn on ever message received

with_close

</>

pub fn with_close(make_pool: fn(ListenSocket) -> Pool(a), func: fn(
    Subject(HandlerMessage),
  ) -> Nil) -> fn(ListenSocket) -> Pool(a)

Add an on_close handler to the acceptor pool

with_init

</>

pub fn with_init(make_pool: fn(ListenSocket) -> Pool(a), func: fn(
    Subject(HandlerMessage),
  ) -> Nil) -> fn(ListenSocket) -> Pool(a)

Add an on_init handler to the acceptor pool

with_pool_size

</>

pub fn with_pool_size(make_pool: fn(ListenSocket) -> Pool(a), pool_count: Int) -> fn(
  ListenSocket,
) -> Pool(a)

Adjust the number of TCP acceptors in the pool