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 umResult<Address<M>, hive.syslink.SyslinkError>, com oMlido do handler;spawn(handler, state, #Name)também o registra sob um átomo, e falha comoTakense outro serviço tiver o nome.at(#Name)é o serviço registrado sob aquele nome aqui, eat(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 oattira o seuMde 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.
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
}
}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 }
}
}