En el paso anterior una app guardaba varias conversaciones. Ahora los miembros de una conversación se ponen de acuerdo en dos listas: quién está en ella y qué salas tiene.
Los mensajes no necesitan un orden acordado. Cada miembro escribe su propio log, y dos mensajes escritos en el mismo momento se pueden mostrar en cualquier orden sin que nadie pierda nada: conmutan. La lista de miembros y la lista de salas son distintas: son estado compartido. Dos admins pueden actuar en el mismo momento, uno quitando a Carol mientras el otro aprueba a Dave, o los dos añadiendo una sala llamada "design", y todos los miembros tienen que terminar con las mismas listas. kolo-braid da eso: une las entradas de todos los miembros en un solo orden que cada peer calcula igual, y una función apply que escribes tú convierte ese orden en las listas. El chat mantiene sus mensajes, perfiles y entrega sin conexión como estaban, lleva solo las dos listas compartidas a un braid, y habla solo con las personas que están en la lista de miembros acordada.
Lo que esta lista no puede hacer: un admin se elige cuando se aprueba una solicitud y lo sigue siendo, el miembro que asienta el orden (la persona que empezó la conversación) no se puede quitar, y quitar a alguien surte efecto en la app de cada miembro solo cuando esa app se entera. Quitar a alguien no cambia la clave de la conversación, así que no es una revocación: la persona quitada conserva la clave y lo que recibió. Un miembro quitado conserva todo lo que recibió y la clave; cualquier app que no se haya enterado de que lo quitaron todavía le da lo que tiene. kolo-braid está en beta: su asentamiento y su membresía se verificaron con model checking dentro de unos límites, lo que no es una prueba, y se probó en un Mac, solo en 127.0.0.1, nunca en una red real.
Tú escribes la lección: la función apply, en state.go, y el braid de una conversación, en braid.go: abrirlo, con quién habla el chat, el único lugar que entrega una conexión al braid y los cambios que hace un admin. Todo lo demás es la fontanería que lleva esto por la app, y lo traes desde la etiqueta step-7.
1Comprueba lo que necesitas y trae los archivos dados
Necesitas lo mismo que en el paso 6: Go 1.26 o superior, Node.js, wails3, el nodo de bootstrap y un pin local. Parte del proyecto que terminaste en el paso 6. Trae las etiquetas:
git fetch origin --tagsTrae la ventana, los archivos del módulo, la fontanería y las pruebas de este paso. Reemplazan tus archivos del paso 6 con el mismo nombre:
git checkout step-7 -- frontend go.mod go.sum mux.go braidstatus.go chatservice.go conversations.go invite.go pin.go profile.go '*_test.go'| Archivo | Qué hace |
|---|---|
frontend/ | La ventana: aprobar como miembro o como admin, Remove con su confirmación, marcas para los cambios pendientes y las frases de chat:state. |
go.mod, go.sum | Añaden kolo-braid v0.1.0 y lo que necesita. |
mux.go | Reparte una conexión entre los mensajes del chat, el kolo-sync del chat y el braid, con un byte de etiqueta al principio de cada stream. |
braidstatus.go | Lo que la ventana muestra sobre las listas (chat:state), y la pausa de un miembro cuyo braid rompe el protocolo. |
chatservice.go | Abre el almacén del braid al arrancar y el braid en enter, da un mux a cada conexión, pone el ID de nuestro braid en el hello y consulta el conjunto aceptado antes de registrar, responder, servir, leer o mostrar a alguien. |
invite.go | Cada invitación espera a un admin; quien se une envía una solicitud de unión al braid y completa su braid con la bienvenida que lleva la invitación. |
profile.go | Los perfiles se quedan en el directorio kolo-kv de cada miembro; las listas de salas y de miembros del dueño desaparecen. |
pin.go | La lectura del pin toma solo a los autores de la lista de miembros. |
conversations.go | La organización 3, los envoltorios de las llamadas nuevas, una unión que falla borra su carpeta, y las comprobaciones de la carpeta de datos al arrancar. |
*_test.go | Las pruebas de este paso. |
La etiqueta también tiene state.go y braid.go terminados, por si quieres comparar los tuyos. Hasta que los escribas, el proyecto no compila.
2Una conexión para el chat y el braid
kolo-swarm mantiene una conexión por clave de peer, y los mensajes del chat, el servidor kolo-sync del chat y el ServeConn del braid tienen que ser, cada uno, el único que acepta streams en esa conexión. Por eso mux.go hace que cada stream empiece con un byte de etiqueta: m para los mensajes del chat, en streams uni; s para el kolo-sync del chat, en streams bidi; y b para el braid, en los dos. Cada stream aceptado recibe una goroutine propia, que lee la etiqueta y entrega el stream a su parte; una etiqueta equivocada o tardía cancela solo ese stream. Cada parte parece una conexión entera para kolo-sync y kolo-braid, y su Close termina solo esa parte. Cada conexión admite 64 streams entrantes por dirección, así que un braid ocupado nunca se queda con el crédito que necesita el chat:
const (
tagMsg = 'm'
tagSync = 's'
tagBraid = 'b'
// maxStreams is the incoming streams per direction a connection allows: 16 for the braid's pulls, 16 for the
// chat's kolo-sync streams and 32 for the uni messages of both.
maxStreams = 64
// maxWaiting is how many streams a braid part may hold waiting; one more is a fault, which closes the part and
// frees its streams at once. UNSOURCED: half of maxStreams, so a stuck braid never holds the credit the chat needs.
maxWaiting = maxStreams / 2
codeBadTag = 3
)Un peer del paso 6 envía streams sin etiqueta, así que las dos versiones no hablan entre sí.
3Escribe la función apply
El braid guarda la lista de miembros por sí mismo. Tu función apply guarda la lista de salas. Una entrada de datos del chat tiene un formato de bytes fijo, no JSON: el byte 0 es la versión, el byte 1 la operación, el byte 2 la longitud del nombre en bytes, y después el nombre. La versión 1 tiene una operación, "añadir una sala". La función apply tiene que dar el mismo resultado en cada peer, así que lee solo la vista, la entrada y la lista de miembros en la posición de la entrada, nunca un reloj ni el orden de un mapa.
Crea state.go con:
package main
// The shared state of a conversation: the room list, kept by kolo-braid.
//
// The braid keeps the member list itself (Snapshot.Members), so the view holds only the rooms. A data entry of the chat
// is a fixed byte layout: byte 0 the version, byte 1 the op, byte 2 the name's length in bytes, then the name. Version 1
// has one op, "add a room".
import (
"errors"
"fmt"
"slices"
kolobraid "github.com/ciranda-dev/kolo-braid"
)Añade a state.go el nombre del estado de la app y la clave de la lista de salas:
const (
stateApp = "kolochat/state/v1"
roomV1 = 1
opAddRoom = 1
)
var keyRooms = []byte("rooms")Las comprobaciones siguen un orden fijo. Toda entrada que no sea de datos devuelve nil, porque la biblioteca aplica lo que hacen las entradas de membresía. Un escritor que no es admin se rechaza antes de leer la versión, así que las apps viejas y las nuevas coinciden en eso y un miembro no puede detener la vista de nadie. Una versión mayor que 1 es un error, que detiene esta app hasta que se actualice: lo que añada una versión posterior va después del byte 0, así que una app vieja nunca rechaza una entrada que no entiende. Añade a state.go:
// applyState keeps the view key "rooms", the sorted list of rooms admins added. It reads only the view, the entry and
// the roster at the entry's position, so every peer computes the same list.
func applyState(tx *kolobraid.Tx, e *kolobraid.Entry) error {
if e.Kind != kolobraid.KindData {
return nil // the library applied the membership effect
}
// Before the version: old and new apps agree on a non-admin's entry, so nobody can halt every view.
if m, ok := tx.Member(e.Writer); !ok || m.Roles&kolobraid.RoleAdmin == 0 {
return kolobraid.Reject("not an admin")
}
b := e.Body
switch {
case len(b) == 0 || b[0] == 0:
return kolobraid.Reject("no version")
case b[0] > roomV1: // a later version halts this app until it is updated, and is never rejected
return fmt.Errorf("room entry of version %d", b[0])
case len(b) < 3 || b[1] != opAddRoom || int(b[2]) != len(b)-3:
return kolobraid.Reject("not a version 1 room entry")
}
name := string(b[3:])
raw, err := tx.Get(keyRooms)
if err != nil && !errors.Is(err, kolobraid.ErrNotFound) {
return err
}
rooms, err := decodeRooms(raw)
if err != nil {
return err
}
switch {
case validRoomName(name) != nil, sameRoom(name, defaultRoom):
return kolobraid.Reject("bad room name")
case slices.ContainsFunc(rooms, func(r string) bool { return sameRoom(r, name) }):
return kolobraid.Reject("room exists")
case len(rooms) >= maxRooms:
return kolobraid.Reject("too many rooms")
}
rooms = append(rooms, name)
slices.Sort(rooms)
return tx.Put(keyRooms, encodeRooms(rooms))
}La lista de salas en la vista es una lista de nombres, cada uno con su longitud delante:
// encodeAddRoom is the body of an entry that adds the room name, which validRoomName accepts: at most 128 bytes.
func encodeAddRoom(name string) []byte {
return append([]byte{roomV1, opAddRoom, byte(len(name))}, name...)
}
// encodeRooms writes the room list as length-prefixed names.
func encodeRooms(rooms []string) []byte {
var out []byte
for _, r := range rooms {
out = append(append(out, byte(len(r))), r...)
}
return out
}
func decodeRooms(b []byte) ([]string, error) {
var rooms []string
for len(b) > 0 {
n := int(b[0])
if n == 0 || len(b) < 1+n {
return nil, errors.New("damaged room list")
}
rooms, b = append(rooms, string(b[1:1+n])), b[1+n:]
}
return rooms, nil
}
// roomsOf reads the rooms admins added from a snapshot of the braid's view.
func roomsOf(s *kolobraid.Snapshot) []string {
raw, err := s.Get(keyRooms)
if err != nil {
return nil
}
rooms, _ := decodeRooms(raw)
return rooms
}Dos salas tienen el mismo nombre cuando sus letras ASCII coinciden sin importar mayúsculas, y cada otro byte coincide tal cual. Las tablas Unicode de Go nunca deciden lo que aplica un peer:
// sameRoom compares two names with ASCII letters folded and every other byte as is: Go's Unicode tables never decide
// what a peer applies.
func sameRoom(a, b string) bool {
if len(a) != len(b) {
return false
}
for i := range len(a) {
if lowerASCII(a[i]) != lowerASCII(b[i]) {
return false
}
}
return true
}
func lowerASCII(c byte) byte {
if 'A' <= c && c <= 'Z' {
return c + 'a' - 'A'
}
return c
}4Abre el braid
Cada conversación tiene un braid en su propio almacén, braid/, junto a store/, con el kolo-id de la conversación como su clave de miembro. Su génesis fija el grupo: un solo asentador, la persona que empieza la conversación; como mucho 64 miembros, el valor por defecto de kolo-braid; y cuerpos de como mucho 1 KiB, su mínimo. El fundador crea el braid; quien se une lo recibe de la bienvenida que lleva su invitación.
Crea braid.go con:
package main
//lint:file-ignore ST1005 these errors are sentences the window shows as they are
// The braid of a conversation: the member list and the room list, which every member must end with alike.
//
// Each member writes its own strand, and kolo-braid merges them into one order that every peer computes the same way;
// applyState (state.go) turns that order into the room list, and the braid keeps the roster. The chat talks only to
// the keys on that roster (the accepted set): a hello that proves the conversation key and names our group starts the
// braid's sync, and only an accepted key is registered, served, pulled and shown. Removing a member is not
// revocation: it keeps the conversation key.
import (
"cmp"
"context"
"encoding/hex"
"errors"
"log"
"path/filepath"
"slices"
"strings"
"time"
kolobraid "github.com/ciranda-dev/kolo-braid"
kolodht "github.com/ciranda-dev/kolo-dht"
invite "github.com/ciranda-dev/kolo-invite"
kolosecure "github.com/ciranda-dev/kolo-secure"
kolostore "github.com/ciranda-dev/kolo-store"
kolotransport "github.com/ciranda-dev/kolo-transport"
)Añade los límites, el grupo y las frases que muestra la ventana:
const (
// braidWrite bounds every braid write: kolo-braid's ConfirmWait.
braidWrite = 10 * time.Second
stateTick = time.Second
codeRestart = 2 // closes a connection so both braids start fresh on the next one
)
// groupConfig is fixed in the genesis: one settler, the founder; 64 members, kolo-braid's default; 1 KiB bodies, its
// least.
var groupConfig = kolobraid.GroupConfig{
App: stateApp, Quorum: kolobraid.Majority, MaxMembers: maxMembers, MinSettlers: 1, MaxSettlers: 1, MaxBody: 1024,
}
var (
ErrNotAdmin = errors.New("Only an admin can do that.")
ErrFull = errors.New("This conversation has 64 members, the most it can have.")
ErrWaitingForMember = errors.New("Waiting for another member to come online.")
ErrCannotWrite = errors.New("This copy of the conversation can no longer write: ask an admin to invite you again.")
ErrSettler = errors.New("The member who settles changes to members and rooms cannot be removed.")
ErrUnknownMember = errors.New("That person is not on the member list.")
errNoBraid = errors.New("the shared member list of this conversation is missing")
)Abre el braid. noBraidYet decide qué es una carpeta sin conversation.json: una unión que no terminó, o la carpeta de un miembro que perdió el archivo, que se rechaza:
func braidOptions(db kolostore.Backend) kolobraid.Options {
// MaxPullAhead is twice the least, so a settler's next pulse is always in reach.
return kolobraid.Options{Backend: db, App: stateApp, Apply: applyState, Limits: &kolobraid.Limits{MaxPullAhead: 128}}
}
// dhtConfig gives every connection 64 incoming streams per direction: the chat and the braid share them (mux.go).
func dhtConfig() *kolodht.Config {
return &kolodht.Config{Secure: &kolosecure.Config{Transport: &kolotransport.Config{MaxIncomingStreams: maxStreams}}}
}
func openBraidStore(dir string) (kolostore.Backend, error) {
return kolostore.OpenPebble(filepath.Join(dir, "braid"))
}
// openBraid opens the conversation's braid, or creates it for the person who starts the conversation. A joiner has
// it from Complete already.
func (c *ChatService) openBraid(founder bool) (err error) {
if c.braid != nil {
return nil
}
c.braid, err = kolobraid.Open(c.ctx, c.id, braidOptions(c.braidDB))
if errors.Is(err, kolobraid.ErrNotFound) {
if !founder {
return errNoBraid
}
c.braid, err = kolobraid.Create(c.ctx, c.id, groupConfig, braidOptions(c.braidDB))
}
return err
}
// noBraidYet refuses a folder without conversation.json that holds anything of a member: a completed braid, a copy
// of another member's log, or entries in our own logs. Such a folder lost the file, and is never taken for a join
// that did not finish.
func (c *ChatService) noBraidYet() error {
b, err := kolobraid.Open(c.ctx, c.id, braidOptions(c.braidDB))
if err == nil {
b.Close()
return &DataDirError{Dir: c.set.DataDir}
}
if !errors.Is(err, kolobraid.ErrNotFound) {
return err
}
all, err := c.store.List()
if err != nil {
return err
}
if len(all) > 2 || c.log.Len() > 0 || c.dirLog.Len() > 0 {
return &DataDirError{Dir: c.set.DataDir}
}
return nil
}5Habla solo con los miembros
Un hello tiene dos resultados. Está probado cuando prueba la clave de la conversación y nombra nuestro braid. Un peer está aceptado cuando está probado y en la lista de miembros de la vista del braid. El conjunto aceptado vive en memoria y se reconstruye desde una sola instantánea en cada evento del braid. Cuando un peer pasa a estar aceptado, el chat lo registra; cuando sale de la lista, el chat lo suelta. Añade a braid.go:
// startBraid builds the accepted set before anything is pulled, and follows the braid's events.
func (c *ChatService) startBraid() {
c.mu.Lock()
c.group = c.braid.GroupID()
c.pauses = map[string]*pause{}
c.mu.Unlock()
c.rebuild()
c.wg.Go(c.stateLoop)
}
// stateLoop follows the braid's events and, at least every stateTick, tells the window the lists and the state. Every
// event rebuilds the accepted set from the whole roster, so an event dropped past MaxEvents changes nothing: the
// events after it rebuild.
func (c *ChatService) stateLoop() {
for {
ctx, cancel := context.WithTimeout(c.ctx, stateTick)
ev, err := c.braid.Next(ctx)
cancel()
if c.ctx.Err() != nil || errors.Is(err, kolobraid.ErrClosed) {
return
}
if err == nil {
c.rebuild()
switch ev.Kind {
case kolobraid.EventHalted, kolobraid.EventDiverged, kolobraid.EventSettlementHalted, kolobraid.EventStrandLost:
log.Printf("member list: event %d at %d", ev.Kind, ev.Position)
}
}
c.publishDirectory()
c.emitState(c.braid.Status())
}
}
// rebuild reads the roster from one snapshot of the view into the accepted set. Proven peers that are now accepted
// are registered, get a reply hello and a sync; registered peers that are not accepted any more are dropped.
func (c *ChatService) rebuild() {
snap := c.braid.View()
members := snap.Members()
snap.Close()
accepted := make(map[string]kolobraid.Member, len(members))
for _, m := range members {
accepted[hex.EncodeToString(m.Key)] = m
}
c.mu.Lock()
c.accepted = accepted
var join []*link
dropped := false
for key, l := range c.links {
_, ok := accepted[key]
switch {
case ok && !l.registered && l.hello != nil:
join = append(join, l)
case !ok && l.registered:
l.registered, dropped = false, true
log.Print("not on the member list: ", key[:8])
}
}
c.mu.Unlock()
for _, l := range join {
c.accept(l, *l.hello, true, true)
}
if dropped {
c.emitPeers()
}
}
// isAccepted says whether author, a hex key, is on the roster of the view.
func (c *ChatService) isAccepted(author string) bool {
c.mu.Lock()
defer c.mu.Unlock()
_, ok := c.accepted[author]
return ok
}
// IsAdmin says whether we are an admin: who may invite, approve, remove members and add rooms.
func (c *ChatService) IsAdmin() bool {
c.mu.Lock()
defer c.mu.Unlock()
m, ok := c.accepted[hex.EncodeToString(c.pub)]
return ok && m.Roles&kolobraid.RoleAdmin != 0
}El chatservice.go dado comprueba el conjunto aceptado en todos los caminos del chat: antes de registrar o responder un hello, mostrar un mensaje, servir nuestros logs, o leer el log de un miembro desde el miembro o desde el pin. Así sirve nuestros logs:
if c.isAccepted(hex.EncodeToString(peer)) && owner.Equal(c.pub) && (logID == c.log.ID() || logID == c.dirLog.ID()) {6Entrega una conexión al braid
Un hello probado arranca los streams bidi y la sincronización del braid, también para alguien que todavía no está en la lista de miembros, para que quien se une pueda sincronizar su propia admisión. Un peer que no envía hello es alguien que se une con una invitación, y recibe en su lugar el protocolo de invitación. Este es el único lugar donde una conexión se encuentra con el braid. Añade a braid.go:
// serveAfterHello serves our logs and the braid to the peer once its hello is proven: it knows the conversation key
// and names our braid. Who is not on the roster yet still gets the braid, so a joiner can sync its own admission. A
// peer that sends no hello in sendTimeout is someone who joins with an invite: one who left keeps its announcement of
// the topic for up to 20 minutes (kolo-dht's record lifetime), so the topic alone does not tell.
func (c *ChatService) serveAfterHello(l *link) {
timer := time.NewTimer(sendTimeout)
defer timer.Stop()
select {
case <-l.proven:
c.wg.Go(l.mx.acceptBidi)
c.wg.Go(func() { c.serveBraid(l) })
c.srv.Serve(c.ctx, l.mx.part(tagSync))
case <-timer.C:
c.mu.Lock()
if c.links[l.key] == l {
delete(c.links, l.key)
}
c.mu.Unlock()
c.inv.ServePeer(c.ctx, l.p)
case <-c.ctx.Done():
}
}El braid se sincroniza en la parte b de la conexión. Solo ErrNotMember, una clave que el braid no conoce desde hace 60 segundos, cierra la conexión, así que el swarm vuelve a conectar y los dos braids empiezan de cero: alguien que se une y conoció a otro antes de que se ordenara su admisión, o un miembro quitado. Un braid que rompe el protocolo se pausa con ese miembro, y el chat sigue:
// serveBraid syncs the braid with one peer on the connection's 'b' part. Only ErrNotMember closes the connection; a
// braid fault pauses the braid with that member and the chat goes on.
func (c *ChatService) serveBraid(l *link) {
conn := l.p.Conn()
for {
if wait := c.pausedFor(l.key); wait > 0 {
t := time.NewTimer(wait)
select {
case <-t.C:
case <-conn.Context().Done():
t.Stop()
return
case <-c.ctx.Done():
t.Stop()
return
}
c.unpause(l.key)
conn.CloseWithError(codeRestart, "kolochat: braid starts fresh")
return
}
part := l.mx.part(tagBraid)
c.served(l.key)
err := c.braid.ServeConn(c.ctx, part)
part.Close()
switch {
case errors.Is(err, kolobraid.ErrNotMember): // unknown for 60 s: a joiner tries again, a removed member redials
conn.CloseWithError(codeRestart, "kolochat: not a member")
return
case errors.Is(err, kolobraid.ErrProtocol), part.overflowed.Load():
c.braidFault(l.key)
default:
return
}
}
}7Añade salas, quita y aprueba miembros
Cada escritura en el braid tiene un límite de 10 segundos, el ConfirmWait de kolo-braid. Solo un admin escribe. Un admin añade una sala añadiendo una entrada, y quita a un miembro con una llamada al braid. El asentador no se puede quitar:
// writeCtx bounds a braid write.
func (c *ChatService) writeCtx() (context.Context, context.CancelFunc) {
return context.WithTimeout(c.ctx, braidWrite)
}
// writeError turns an error of a braid write into the sentence the window shows.
func (c *ChatService) writeError(err error) error {
switch {
case err == nil:
return nil
case errors.Is(err, kolobraid.ErrUnconfirmed):
c.mu.Lock()
c.unconfirmed = true
c.mu.Unlock()
return ErrWaitingForMember
case errors.Is(err, kolobraid.ErrStrandLost):
return ErrCannotWrite
case errors.Is(err, kolobraid.ErrNotAdmin), errors.Is(err, kolobraid.ErrRemoved), errors.Is(err, kolobraid.ErrNotMember):
return ErrNotAdmin
}
return err
}
// AddRoom adds a room to the room list, which admins write: anyone else gets ErrNotAdmin. A bad name is
// ErrInvalidRoom, and a room that exists (ASCII letters in any case) is ErrRoomExists. Two admins who add one name at
// once end with one room.
func (c *ChatService) AddRoom(name string) error {
name = strings.TrimSpace(name)
if !c.isActive() {
return ErrNotInConversation
}
if !c.IsAdmin() {
return ErrNotAdmin
}
if err := validRoomName(name); err != nil {
return err
}
rooms := c.Rooms()
if slices.ContainsFunc(rooms, func(r string) bool { return sameRoom(r, name) }) {
return ErrRoomExists
}
if len(rooms) > maxRooms {
return ErrTooManyRooms
}
ctx, cancel := c.writeCtx()
defer cancel()
_, err := c.braid.Append(ctx, encodeAddRoom(name))
return c.writeError(err)
}
// RemoveMember takes a member off the member list. Each member's app stops talking to it once it learns of this; the
// member keeps the conversation key, so this is not revocation. The settler cannot be removed.
func (c *ChatService) RemoveMember(key string) error {
if !c.isActive() {
return ErrNotInConversation
}
if !c.IsAdmin() {
return ErrNotAdmin
}
c.mu.Lock()
m, ok := c.accepted[key]
c.mu.Unlock()
switch {
case !ok:
return ErrUnknownMember
case m.Seat:
return ErrSettler
}
ctx, cancel := c.writeCtx()
defer cancel()
_, err := c.braid.RemoveMember(ctx, m.Key)
if err == nil {
log.Print("member removed: ", key[:8])
}
return c.writeError(err)
}Ahora cada invitación espera a un admin, porque cada persona que se une necesita una bienvenida propia del braid. Approve comprueba primero el límite de miembros, después admite a quien se une con su rol, y después responde a la invitación con la bienvenida. Si la invitación ya no puede llevarla, quien se unía se quita de nuevo. El rol se queda para siempre: kolo-braid no tiene una forma pública de cambiarlo después:
// Approve lets in the person behind a request, as a member or as an admin; the role stays for good. The braid gets
// its AddMember entry, and the invite carries the conversation and the braid's welcome. If the invite cannot carry it,
// the joiner is removed again. Deny refuses it. Both need an admin.
func (c *ChatService) Approve(request uint64, admin bool) error {
if c.inv == nil {
return errors.New("not started")
}
if !c.IsAdmin() {
return ErrNotAdmin
}
c.mu.Lock()
r, ok := c.requests[invite.RequestID(request)]
full := len(c.accepted) >= maxMembers
c.mu.Unlock()
switch {
case !ok:
return ownerError(invite.ErrNotFound)
case full:
return ErrFull
}
var role kolobraid.Role
if admin {
role = kolobraid.RoleAdmin
}
ctx, cancel := c.writeCtx()
defer cancel()
welcome, err := c.braid.Admit(ctx, r.ev.Joiner, r.data.Request, &kolobraid.AdmitOptions{Roles: &role})
if err != nil {
c.answer(request, func(id invite.RequestID) error { return c.inv.Deny(id) })
if !admitRefused(err) {
c.braid.RemoveMember(ctx, r.ev.Joiner) // a write failed after the AddMember entry
}
return c.writeError(err)
}
payload, err := c.grantPayload(welcome)
if err == nil {
err = c.answer(request, func(id invite.RequestID) error { return c.inv.Approve(id, payload) })
}
if err != nil {
c.braid.RemoveMember(ctx, r.ev.Joiner) // the invite ended meanwhile
return ownerError(err)
}
log.Print("member admitted: ", hex.EncodeToString(r.ev.Joiner)[:8])
return nil
}
// admitRefused says that Admit wrote nothing, so there is nothing to remove.
func admitRefused(err error) bool {
return errors.Is(err, kolobraid.ErrActiveKey) || errors.Is(err, kolobraid.ErrKnownStrand) ||
errors.Is(err, kolobraid.ErrInvalidArgument) || errors.Is(err, kolobraid.ErrNotAdmin) ||
errors.Is(err, kolobraid.ErrRemoved) || errors.Is(err, kolobraid.ErrUnconfirmed)
}8Lee las listas
La ventana lee las dos listas del braid. Pending marca a un miembro cuya admisión todavía no está asentada:
// Rooms lists the rooms of the conversation: the default room, then the ones admins added, by name.
func (c *ChatService) Rooms() []string {
rooms := []string{defaultRoom}
if c.braid == nil {
return rooms
}
snap := c.braid.View()
defer snap.Close()
return append(rooms, roomsOf(snap)...)
}
// Members lists the member list of the conversation with their profiles: the settler first, then the admins, then
// the others by key. Pending says the change that added it is not settled yet. A joiner whose braid has not synced
// yet lists itself.
func (c *ChatService) Members() []Member {
if c.braid == nil {
return []Member{} // "chat:profiles" sends it as is, and a nil slice would be null
}
view, settled := c.braid.View(), c.braid.Settled()
roster, done := view.Members(), settled.Members()
view.Close()
settled.Close()
me := hex.EncodeToString(c.pub)
out := make([]Member, 0, len(roster)+1)
for _, m := range roster {
key := hex.EncodeToString(m.Key)
p := c.profileOf(key)
out = append(out, Member{Key: key, Name: p.Name, Avatar: p.Avatar, Admin: m.Roles&kolobraid.RoleAdmin != 0, Seat: m.Seat,
Pending: !slices.ContainsFunc(done, func(d kolobraid.Member) bool { return d.Key.Equal(m.Key) })})
}
if !slices.ContainsFunc(out, func(m Member) bool { return m.Key == me }) {
p := c.profileOf(me)
out = append(out, Member{Key: me, Name: p.Name, Avatar: p.Avatar, Pending: true})
}
slices.SortStableFunc(out, func(a, b Member) int {
rank := func(m Member) int {
switch {
case m.Seat:
return 0
case m.Admin:
return 1
}
return 2
}
return cmp.Or(cmp.Compare(rank(a), rank(b)), strings.Compare(a.Key, b.Key))
})
return out
}9Lo que hace la ventana con esto
La ventana muestra las frases de chat:state debajo del chat:
{joined ? stateBanners(conv.state).map((text) => <p key={text} className="note">{text}</p>) : null}Una solicitud tiene dos botones de aprobar, uno por rol:
<button type="button" className="btn" onClick={() => answer((q) => Approve(conv, q, false), r.request)}>Approve as member</button>
<button type="button" className="btn btn--ghost" onClick={() => answer((q) => Approve(conv, q, true), r.request)}>Approve as admin</button>Y Remove, después de una confirmación que dice lo que quitar no hace, llama a RemoveMember:
await RemoveMember(conv, who.key)10Ejecútalo
Arranca el nodo de bootstrap y déjalo en marcha:
go run ./cmd/bootstrapEn otra terminal, arranca el pin local y déjalo en marcha:
go run github.com/ciranda-dev/kolo-pin/cmd/kolo-pin run -data .data/pin -max-bytes 100MBCompila la app:
GOWORK=off wails3 buildLas carpetas de datos del paso 6 ahora se rechazan, así que usa carpetas nuevas. Alice necesita la clave pública del pin, solo en su terminal:
export KOLO_CHAT_PIN_KEY=$(go run github.com/ciranda-dev/kolo-pin/cmd/kolo-pin id -data .data/pin)./bin/kolo-chat -data .data/alice-7En la ventana de Alice haz clic en New conversation, escribe "Team" y haz clic en Create. Ella la funda: es admin y asienta el orden de los cambios.
Arranca a Bob, Carol y Dave, cada uno en una terminal propia, sin la variable:
./bin/kolo-chat -data .data/bob-7./bin/kolo-chat -data .data/carol-7./bin/kolo-chat -data .data/dave-7En la ventana de Alice haz clic en Invite y crea una invitación para Bob. En la ventana de Bob haz clic en Join with an invite, pega el código y haz clic en Join. En la ventana de Alice haz clic en "Approve as admin". Invita a Carol de la misma forma y haz clic en "Approve as member". Ahora Bob es admin: tiene el botón Invite y la caja para una sala nueva; Carol no tiene ninguno de los dos.
Ahora dos admins actúan en el mismo momento. En la ventana de Alice y en la de Bob, escribe "design" en la caja para una sala nueva y pulsa Enter en las dos lo más juntas que puedas. Todas las ventanas terminan con una sola sala llamada "design". Después haz que Bob quite a Carol mientras Alice aprueba a Dave: crea una invitación en la ventana de Alice y empieza la unión de Dave; en la ventana de Bob haz clic en Remove junto a Carol y confirma; en la ventana de Alice haz clic en "Approve as member" para Dave. Todas las ventanas que siguen terminan con la misma lista de miembros: Alice, Bob y Dave.
La ventana de Carol todavía tiene la clave y lo que recibió. Nadie le avisa. En unos minutos, cuando sus conexiones vuelven a empezar, nadie acepta su hello, y su ventana dice que hay miembros conectados pero ninguno responde, así que puede que la hayan quitado.
11Ejecuta las pruebas
Las pruebas que trajiste cubren la función apply en todos los órdenes de entrega, los streams con etiqueta, dos admins que actúan a la vez, un miembro quitado con el que no se habla y que no recibe claves de entrada, un reinicio que conserva las listas, el límite de miembros, una unión que falla, archivos especiales en la carpeta de datos y una carpeta del paso 6:
GOWORK=off go test ./...12Lo que la lista de miembros no puede hacer
- Quitar no es revocar. Quitar a un miembro cambia la lista acordada pero no cambia la clave de la conversación. El miembro quitado conserva la clave y todo lo que recibió, y todavía puede leer lo que consiga: las copias cifradas del pin, con las claves de cualquier app que no se haya enterado de que lo quitaron. Todavía no hay rotación de claves.
- Quitar llega a cada app cuando se entera. Una app que estaba sin conexión, o que desde entonces no ha visto a un admin ni al fundador, todavía habla con el miembro quitado. Al miembro quitado no se le avisa.
- Los admins se eligen al aprobar. Un rol se queda para siempre, y en los admins se confía por completo. El fundador asienta el orden de los cambios y no se puede quitar; mientras el fundador está sin conexión, los cambios aparecen como pendientes.
- Como mucho 64 miembros, siempre con aprobación. Cada solicitud espera a un admin, y Approve con 64 miembros se rechaza.
- Lo que borra un arranque. Como dice la documentación de la app de ejemplo: "At start, a folder without
conversation.jsonis deleted only when it is provably a join that did not finish: nothing in it but a kolo-id with its stores, own logs with no entry, no completed braid and no copy of another member's log. Any other one, such as a member's folder that lost the file, is refused with the folder to move aside, and nothing in it is deleted." Es decir: al arrancar, una carpeta sinconversation.jsonse borra solo si se puede probar que es una unión que no terminó; cualquier otra, como la carpeta de un miembro que perdió el archivo, se rechaza indicando la carpeta que hay que apartar, y no se borra nada en ella. El starter hace lo mismo, y unconversation.jsonque es un FIFO, un enlace o un archivo que no puede leer da una fila con su carpeta, nunca un arranque bloqueado. - Un dispositivo. Una lista local de conversaciones funciona porque un kolo-id vive en un dispositivo: usar una cuenta en varios dispositivos es otro problema y aquí no se resuelve.
- Beta. El asentamiento y la membresía de kolo-braid se verificaron con model checking dentro de unos límites, lo que no es una prueba para cualquier tamaño, y este chat se probó en un Mac, solo en 127.0.0.1, nunca en una red real.
Siguientes pasos
- Arranca en la red pública y mantén la tuya con
-bootstrap: Paso 8: Usar la red pública. - Lee la guía de kolo-braid en la página de kolo-braid, y Construye un documento compartido en dos terminales, donde un braid guarda todo el estado.
- El ejemplo terminado, kolo-chat-wails3-example, añade el traspaso del fundador antes de Leave, marcas para los miembros cuyas entradas se rechazaron, y claves de entrada derivadas. Su
docs/shared-state.mdcuenta cómo. El ejemplo terminado muestra una sola lista de salas, una por conversación, y su pin es opcional: sin él, los mensajes llegan a la gente solo mientras está en línea. - Para comparar tus archivos con los terminados, usa la etiqueta
step-7del repositorio del starter.