Un peer de anclaje puede desconectarse o perder su disco, así que una
aplicación suele guardar cada log en dos o más, gestionados por personas
distintas o situados en lugares distintos.
kolo-pin los elige con Select y les añade el
log con AddMany.
Asigna un grupo a cada peer
La aplicación guarda una lista de peers de anclaje, cada uno un pin.Peer
con su clave, su dirección IPv4 y un Group opcional, como su proveedor o
su región. Los peers de un mismo grupo pueden fallar a la vez, así que
Select elige peers de grupos distintos cuando puede.
Cómo elige Select
Cómo se elige un pin
Hashing de rendezvous: todos los dispositivos calculan la misma elección para un log, sin coordinarse. Aquí los pesos van acortados.
- Para cada pin, el cliente calcula un peso: SHA-256 del ID del pin y del ID del log.
- Los pins se ordenan por peso, del más pesado al más ligero.
- Select toma el pin más pesado de cada grupo hasta tener copias suficientes, 2 por defecto. El pin 1 se salta: su grupo ya tiene el pin 3. Si hay pocos grupos, completan los siguientes más pesados.
- Añade el pin 5, en un grupo nuevo. Para este log queda segundo, así que ocupa el sitio del pin 4. Un log en el que no queda arriba se queda como estaba.
Select(peers, logID, n) usa rendezvous hashing (Thaler y Ravishankar,
1998, el artículo original sobre esta técnica). Cada par de un peer y un
log recibe un peso, el hash SHA-256 del ID del peer seguido del ID del log.
Ganan los peers con los pesos más altos para ese log.
- Todos los dispositivos que tienen la misma lista eligen los mismos peers para un log, sin coordinarse. El orden de la lista no importa.
- Cuando un peer entra o sale, solo se mueven los logs para los que ese peer está entre los elegidos. Todos los demás logs se quedan donde están.
- Cada log tiene su propio orden, así que los logs se reparten por igual entre los peers.
Siguiendo ese orden, Select toma el primer peer de cada grupo hasta tener
n. Si hay menos grupos que n, los siguientes peers con más peso completan
la lista y SharedGroups es true. Un peer sin grupo cuenta como su propio
grupo, los peers con un ID no válido se saltan y, de los IDs repetidos, se
conserva uno. Un n de 0 o menos significa DefaultCopies, 2.
Añade el log con AddMany
Una capacidad nombra a un solo peer de anclaje, así que IssueMany firma
una para cada peer, todas con la misma hora de emisión.
AddMany(ctx, id, peers, log, capabilities, n) añade el log a los n peers
que elige Select, con la capacidad que nombra a cada uno.
Cuando un peer elegido es inalcanzable, AddMany prueba el siguiente peer
no elegido en ese mismo orden, como máximo MaxFallback (2) veces. Ese
siguiente peer puede estar en un grupo que ya se ha usado. Un peer que
responde con un error queda como Refused y no se sustituye. El Report
lista cada intento con su Outcome (Accepted, Refused o
Unreachable) y cuenta cuántos aceptaron. AddMany devuelve ErrNoPeer
solo si no aceptó ninguno, y no hay reintentos en segundo plano: vuelve a
llamarlo más tarde.
Este programa ejecuta tres peers de anclaje por loopback en dos grupos, con sus datos en un directorio temporal, y ancla un log en dos de ellos:
package main
import (
"context"
"fmt"
"log"
"os"
"path/filepath"
"sync"
"time"
koloid "github.com/ciranda-dev/kolo-id"
"github.com/ciranda-dev/kolo-pin"
kolosecure "github.com/ciranda-dev/kolo-secure"
kolostore "github.com/ciranda-dev/kolo-store"
)
func main() {
dir, err := os.MkdirTemp("", "kolo-pin-choose")
if err != nil {
log.Fatal(err)
}
defer os.RemoveAll(dir)
var wg sync.WaitGroup
defer wg.Wait()
ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
// Three pinning peers in two groups; an application reads this list from its configuration.
var peers []pin.Peer
for i, group := range []string{"provider-a", "provider-a", "provider-b"} {
d := filepath.Join(dir, fmt.Sprint("pin", i))
id, err := pin.LoadIdentity(d)
if err != nil {
log.Fatal(err)
}
ln, err := kolosecure.Listen(ctx, "127.0.0.1:0", id, nil)
if err != nil {
log.Fatal(err)
}
defer ln.Close()
wg.Go(func() { pin.Serve(ctx, ln, pin.Options{Dir: d}) })
peers = append(peers, pin.Peer{ID: id.PublicKey(), Addr: ln.Addr().String(), Group: group})
}
alice, err := koloid.Generate()
if err != nil {
log.Fatal(err)
}
st := kolostore.New(kolostore.NewMemory())
defer st.Close()
l, err := st.Create(alice)
if err != nil {
log.Fatal(err)
}
if _, err := l.Append([]byte("chat history")); err != nil {
log.Fatal(err)
}
sel := pin.Select(peers, l.ID(), 2)
fmt.Printf("chosen: %s and %s, shared group: %v\n", sel.Peers[0].Group, sel.Peers[1].Group, sel.SharedGroups)
// One capability per peer, so a fallback peer has one too.
caps, err := pin.IssueMany(alice, peers, pin.Capability{Expires: time.Now().Add(30 * 24 * time.Hour)})
if err != nil {
log.Fatal(err)
}
report, err := pin.AddMany(ctx, alice, peers, l, caps, 2)
if err != nil {
log.Fatal(err)
}
fmt.Printf("accepted by %d peers\n", report.Accepted)
for _, r := range report.Results {
fmt.Printf(" %s: %v, %d entries\n", r.Peer.Group, r.Outcome, r.Info.Entries)
}
}Imprime algo parecido a esto. Los dos grupos pueden salir en el otro orden, porque las claves son nuevas en cada ejecución:
chosen: provider-a and provider-b, shared group: false
accepted by 2 peers
provider-a: accepted, 1 entries
provider-b: accepted, 1 entriesEl programa firma una capacidad para cada peer de la lista, no solo para
los elegidos. Un peer de reserva sin una capacidad que lo nombre queda como
Refused.
Siguientes pasos
- Ejecuta tu propio peer de anclaje: Ejecuta un peer de anclaje en un VPS.
- Lee la página de kolo-pin para ver todos los límites y errores.