#moonnet

// One request, whichever of the four carries it.
let client = @tls.Client::new(@roots.mozilla(), alpn=["h2"])
let conn = @h2.connect("example.com", port=443, tls=client)
let (response, body) = @spec.call(conn, @spec.Request::new("GET", "/"))
println("\{response.status} \{body.length()}")
conn.close()

#Install

moon add moonbitstack/moonnet

#The contract

pub(open) trait Conn {
  async fn open(self : Self, request : Request) -> Stream
  async fn send(self : Self, stream : Stream, bytes : Bytes, end~ : Bool) -> Unit
  async fn response(self : Self, stream : Stream) -> Response
  async fn read(self : Self, stream : Stream) -> Bytes?
  fn trailers(self : Self, stream : Stream) -> Array[Field]
  fn is_ready(self : Self) -> Bool
  fn kind(self : Self) -> String
  async fn close(self : Self) -> Unit
}

async fn fetch(conn : &@spec.Conn, path : String) -> Bytes {
  let stream = conn.open(@spec.Request::new("GET", path))
  let response = conn.response(stream)
  assert_eq(response.status, 200)
  @spec.read_to_end(conn, stream)
}

#Adapters

// A session, and the reply to what the client said.
async fn hello(url : String, tls : @tls.Client) -> Unit {
  let ws = @ws.connect(url, tls=tls)
  let stream = ws.open(@spec.Request::new("GET", "/chat"))
  let _ = ws.response(stream)
  ws.send(stream, @utf8.encode("hello"), end=false)
  match ws.read(stream) {
    Some(reply) => println(@utf8.decode_lossy(reply[:]))
    None => println("no reply")
  }
  ws.close()
}

#The pool

async fn pooled(tls : @tls.Client) -> Unit {
  let pool = @pool.Pool::new(
    key => {
      let sock = @tcp.dial(key.host, port=key.port, tls=tls)
      @pool.Opened::new(sock, @h2.client(sock, scheme="https", authority=key.host))
    },
    config={ ..@pool.defaults, idle: 60000, max_total: 128 },
  )
  let key = @pool.Key::new("example.com", 443, alpn="h2")
  assert_eq(key.alpn, "h2")
  // The same `fetch` the adapters answer, on a connection the pool chose.
  let conn = pool.get(key)
  let body = fetch(conn, "/")
  println(body.length())
  conn.close()
  pool.close()
}

#UDP and QUIC

async fn datagrams() -> Unit {
  let socket = @udp.bind(port=12000)
  let to = socket.addr()
  socket.send(to, b"ping")
  match socket.recv(timeout=100) {
    Some((bytes, _)) => println("\{bytes.length()} octets")
    None => println("nothing came back")
  }
  socket.close()
}

async fn quic_session(tls : @tls.Client) -> Unit {
  let quic = @udp.dial("example.com", port=443, tls=tls)
  let stream = quic.open_bi()
  quic.write(stream, b"hello", fin=true)
  quic.close()
}

#TCP

@tcp.serve((conn, _) => {
  while conn.read_until("\n") is Some(line) {
    conn.write(line + "\n")
  }
}, port=12000)

#Examples

moon run src/examples/tour --target native

#Conformance

#Licence