A biblioteca padrão
Slide 66 de 85
66openA biblioteca padrão

Respostas enquanto chegam

O httpRequest responde quando o corpo inteiro chegou. Um corpo escrito aos pedaços — a resposta de um modelo de linguagem, um log sendo acompanhado, server-sent events — é lido conforme chega:

  • hive.net.httpOpen(request) envia a requisição e responde assim que o status e os cabeçalhos chegam, com um Result<HttpStream, HttpError>. Um HttpStream tem o status e os headers de um HttpResponse, e um corpo que ainda está chegando. Um 404 continua sendo Ok, e o corpo dele se lê do mesmo jeito.
  • httpReceiveLine(stream) é a próxima linha do corpo, sem a quebra de linha, assim que ela chega; httpReceive(stream, bytes) é no máximo essa quantidade de bytes, o que já tiver chegado. Os dois esperam só na thread que chamou.
  • httpClose(stream) derruba a conexão, que é como um servidor fica sabendo que ninguém está lendo — e como um cliente para um modelo que não para de falar. Pode vir de outra thread enquanto uma leitura espera, e essa leitura responde Closed.

Os erros são um hive.net.HttpStreamError: Closed quando o corpo terminou ou o stream foi fechado, Receive quando a conexão cai no meio. Nada limita a espera além de conectar, já que um servidor de modelo só responde depois de carregar o modelo, então um programa com outra coisa para fazer lê numa thread própria.

O servidor do exemplo é um substituto, para o programa não precisar de nada instalado. O httpServe responde com o corpo inteiro, então ele mesmo escreve o HTTP necessário, por um socket.

A resposta de um modelo, palavra por palavra
type Chunk {
	content: Str
	done: Bool
}

// Um substituto para o servidor de um modelo: uma linha JSON por palavra, uma
// de cada vez.
proc model(conn: hive.net.SocketConnection): void {
	for ; true; {
		if hive.net.socketReceiveLine(conn) is Result.Ok(line) && line != "" {
			continue
		}
		break
	}
	hive.net.socketSend(conn, "HTTP/1.1 200 OK\r\nConnection: close\r\n\r\n")
	for each word in ["A luz", " se espalha,", " e o azul", " se espalha", " mais."] {
		hive.task.sleep(50)
		hive.net.socketSend(conn, encode(Chunk(word, false), hive.json.codec()) + "\n")
	}
	hive.net.socketSend(conn, encode(Chunk("", true), hive.json.codec()) + "\n")
}

proc main(): void {
	async hive.net.socketServe(9025, model)
	hive.task.sleep(200)

	asked := hive.net.HttpRequest("GET", "http://127.0.0.1:9025/", [], "")
	if hive.net.httpOpen(asked) is Result.Ok(stream) {
		mut going := true
		for ; going; {
			going = false
			if hive.net.httpReceiveLine(stream) is Result.Ok(line) {
				if Chunk.decode(line, hive.json.codec()) is Result.Ok(piece) {
					// hive.term.print não termina a linha: as palavras se juntam
					// conforme chegam.
					hive.term.print(piece.content)
					going = piece.done == false
				}
			}
		}
		hive.term.println("")
		hive.net.httpClose(stream)
	}
}