Threads e serviços
Slide 47 de 85
47spawnThreads e serviços

Serviços

Um serviço é um estado com uma caixa de correio, alcançado pelo seu Address<M> — M sendo as mensagens que ele recebe — a partir deste processo ou de outra máquina pela mesma instrução. Três funções nativas fazem o trabalho:

  • spawn(handler, state) inicia um e responde com um Result<Address<M>, hive.syslink.SyslinkError>, com o M lido do handler; spawn(handler, state, #Name) também o registra sob um átomo, e falha como Taken se outro serviço tiver o nome.
  • at(#Name) é o serviço registrado sob aquele nome aqui, e at(endpoint, #Name) o de outro nó — construindo um endereço, sem procurar nada. Um nome não diz nada sobre o que o serviço recebe, então o at tira o seu M de onde ele cai — Address<Note> box = at(#Cache) — ou, ligado com :=, do seu primeiro envio depois, e fica com ele.
  • kill(address) para um, em qualquer nó; matar um duas vezes é inofensivo, e o nome dele fica livre de novo antes de alguém saber que ele parou.

Um handler é uma volta, proc(state: mut S, msg: M): M: ele escreve o estado no lugar e responde com uma mensagem do próprio tipo, e pode receber um terceiro parâmetro, o próprio Address<M>, para entregar ao trabalho que inicia. Só a caixa de correio do serviço guarda o estado, uma mensagem por vez, então nada precisa de trava — e um teste chama um handler diretamente com uma variável mut própria. Um handler cujos ramos retornam todos, numa cadeia que cobre o tipo da mensagem, transforma uma mensagem acrescentada depois em erro de compilação.

Chamar um endereço é um pedido: box(msg) espera a resposta, como um Result<M, SyslinkError>, por até cinco segundos a menos que with timeout diga outra coisa; async box(msg) envia e esquece, a resposta descartada; x := async box(msg) e await [a(m), b(m)] enviam agora e esperam depois. Um pedido que estoura o tempo ainda espera a vez dele na caixa, à frente dos que vêm atrás. Um endereço carrega o tipo da mensagem, então uma mensagem do tipo errado é erro de compilação; uma enviada a um nome cujo serviço recebe outra coisa falha quando chega, como Decode. Um panic num handler mata só aquele serviço — o nó escreve hive: service Counter crashed: … no stderr, quem chamou fica sabendo com Down, e hive.syslink.monitor(watcher, target, notice) envia notice a um serviço deste nó quando target para. Um endereço com nome sobrevive ao serviço: inicie um novo com o nome, e o endereço antigo o alcança. Um anônimo morre junto.

Toda falha diz qual foi, como uma variante de SyslinkError: Taken, Down, NoProc para um nome que ninguém tem, Timeout, Unreachable, Decode, e, entre nós, NoPeer, NoListener e NoKey — então um switch sobre uma cobre todo jeito de um pedido falhar.

Um serviço neste nó
type Note {
	Say   { text: Str }
	Count
	Total { count: Int }
}

proc tally(state: mut Int, msg: Note): Note {
	if msg is Note.Say(text) {
		echo text
		return msg
	} else if msg is Note.Count {
		state += 1
		return Note.Total(state)
	} else if msg is Note.Total(_) {
		return msg
	}
}

proc main(): void {
	if spawn(tally, 0, #Cache) is Result.Error(err) {
		panic err
	}
	Address<Note> address = at(#Cache)

	async address(Note.Say("oi"))                     // dispara e esquece
	reply := address(Note.Count()) with timeout 250   // envia e espera, limitado
	if reply is Result.Ok(msg) {
		echo msg
	}
}
Trabalho lento, fora do turno
type Note {
	Fetch
	Fetched { text: Str }
	Latest
	Answer  { text: Str }
}

proc desk(latest: mut Str, note: Note, me: Address<Note>): Note {
	if note is Note.Fetch {
		async fetch(me)                // o turno termina agora
		return Note.Answer("começou")
	} else if note is Note.Fetched(text) {
		latest = text                  // o resultado chega como mensagem
		return note
	} else if note is Note.Latest {
		return Note.Answer(latest)
	} else if note is Note.Answer(_) {
		return note
	}
}

proc fetch(back: Address<Note>): void {
	hive.task.sleep(300)
	async back(Note.Fetched("valeu a espera"))
}

proc main(): void {
	if spawn(desk, "nada ainda") is Result.Ok(box) {
		if box(Note.Fetch()) with timeout 500 is Result.Ok(now) { echo now }
		if box(Note.Latest()) with timeout 500 is Result.Ok(first) { echo first }
		hive.task.sleep(500)
		if box(Note.Latest()) with timeout 500 is Result.Ok(later) { echo later }
	}
}