kolo docsbeta

Cómo elegir peers de anclaje

Guarda cada log en dos o más peers de anclaje situados en lugares distintos, elegidos de la misma forma por todos los dispositivos.

En esta página

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

Todos los pasos

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.

  1. Para cada pin, el cliente calcula un peso: SHA-256 del ID del pin y del ID del log.
  2. Los pins se ordenan por peso, del más pesado al más ligero.
  3. 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.
  4. 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:

main.go
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:

Texto
chosen: provider-a and provider-b, shared group: false
accepted by 2 peers
  provider-a: accepted, 1 entries
  provider-b: accepted, 1 entries

El 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