Packages
glisten
0.3.0
9.0.1
9.0.0
9.0.0-rc1
8.0.3
8.0.2
8.0.1
8.0.0
8.0.0-rc1
7.0.1
7.0.0
6.0.0
5.0.0
4.0.0
3.0.0
2.0.0
1.0.0
0.11.0
0.10.2
0.10.1
0.10.0
0.9.3
0.9.2
0.9.1
0.9.0
0.8.2
0.8.1
0.8.0
0.7.0
0.6.9
0.6.8
0.6.7
0.6.6
0.6.5
0.6.4
0.6.3
0.6.2
0.6.1
0.6.0
0.5.1
0.5.0
0.4.0
0.3.2
0.3.1
0.3.0
0.2.2
0.2.1
0.2.0
0.1.3
0.1.2
0.1.1
0.1.0
a shiny Gleam TCP/TLS server
Current section
Files
Jump to
Current section
Files
README.md
# glisten
This is a Gleam wrapper around `gen_tcp` loosely based on [ThousandIsland](https://github.com/mtrudel/thousand_island).
It uses the `gleam_otp` library to handle the supervisor and child processes.
The general structure is similar to ThousandIsland. There is a supervisor that
manages a pool of acceptors. Each acceptor will block on `accept` until a
connection is opened. The acceptor will then spawn a handler process and
then block again on `accept`.
The most obvious entrypoint is `glisten/tcp.{handler, serve}` where `serve`
listens for TCP connections on a given port. It also takes a handler function
wrapper which you can provide functionality to, and the state which each TCP
connection process will hold. This takes the shape of:
```gleam
type Handler =
fn(BitString, #(tcp.Socket, state)) -> actor.Next(#(tcp.Socket, state))
```
## Examples
Here is a basic echo server:
```gleam
pub fn main() {
assert Ok(_) = serve(8080, tcp.handler(fn(msg, state) {
let #(socket, _state) = state
assert Ok(_) = tcp.send(socket, bit_builder.from_bit_string(msg))
actor.Continue(state)
}), Nil)
erlang.sleep_forever()
}
```
But you can also do whatever you want.
```gleam
pub fn main() {
try listener =
tcp.listen(
8000,
[
tcp.Active(
False
|> dynamic.from
|> dynamic.unsafe_coerce,
),
],
)
try socket = tcp.accept(listener)
try msg = tcp.do_receive(socket, 0)
io.println("got a msg")
io.debug(msg)
}
```
See [mist](https://github.com/rawhat/mist) for some better examples.