kolo docsbeta

Comparte archivos entre dos terminales

Un tutorial paso a paso. Un terminal comparte un archivo con kolo-blobs y el otro lo recibe con un código para compartir y comprueba cada byte; después, lo mismo con una carpeta y sus versiones con kolo-files.

En esta página

En este tutorial construyes dos programas pequeños y ejecutas cada uno en dos ventanas de terminal de tu ordenador. El primero comparte un archivo: el Terminal 1 lo guarda e imprime un código para compartir, y el Terminal 2 usa el código para traer el archivo, comprobar cada uno de sus fragmentos y guardarlo. El segundo comparte una carpeta entera y mantiene la copia al día: cada vez que cambias la carpeta y pulsas Intro, el otro terminal guarda la versión nueva e imprime lo que ha cambiado.

El primer programa usa kolo-blobs, que guarda los bytes de un archivo. El segundo usa kolo-files, que guarda archivos y carpetas, sus nombres y cada versión sobre kolo-blobs. Todo se queda en tu ordenador, en la dirección 127.0.0.1. El código terminado está en el repositorio kolo-share-example.

1Comprueba lo que necesitas

Necesitas Go 1.26 o posterior y dos ventanas de terminal. Si aún no tienes Go instalado, instálalo para tu sistema:

Descarga el instalador de macOS (el archivo .pkg) desde go.dev/dl y ejecútalo. Si usas Homebrew, también puedes hacerlo así:

bash
brew install go

Comprueba tu versión de Go:

Terminal
go version

Deberías ver la versión 1.26 o una posterior, por ejemplo:

Texto
go version go1.27.3 darwin/arm64

Abre ahora dos ventanas de terminal y ponlas una al lado de otra:

Abre la app Terminal y pulsa Cmd+N para tener una segunda ventana.

En este tutorial se llaman Terminal 1 (el peer que comparte) y Terminal 2 (el peer que recibe).

2Crea una carpeta y un módulo

En el Terminal 1, crea una carpeta para el proyecto y entra en ella:

bash
mkdir kolo-share && cd kolo-share

Después crea un módulo de Go dentro:

Terminal
go mod init example.com/kolo-share

Go responde:

Texto
go: creating new go.mod: module example.com/kolo-share

3Descarga las bibliotecas

Sin salir del Terminal 1, añade las bibliotecas de Kolo que usan los dos programas: kolo-blobs y kolo-files para el contenido, kolo-store para guardarlo en logs en disco, kolo-sync para copiar esos logs al otro peer, kolo-secure para la conexión cifrada, kolo-id para la clave de cada peer y kolo-log para los IDs de los logs.

Terminal
go get github.com/ciranda-dev/kolo-blobs@v0.1.0 github.com/ciranda-dev/kolo-files@v0.1.0 github.com/ciranda-dev/kolo-sync@v0.1.0 github.com/ciranda-dev/kolo-store@v0.1.0 github.com/ciranda-dev/kolo-secure@v0.1.0 github.com/ciranda-dev/kolo-id@v0.1.0 github.com/ciranda-dev/kolo-log@v0.1.0

Go las descarga junto con lo que necesitan e imprime una línea go: added por cada módulo que añade a go.mod.

4Escribe el programa que comparte un archivo

Esto es lo que hace el programa, en cinco pasos:

Todos los pasos

Un archivo, dos terminales

El código para compartir es lo único que pasas a mano. Quien lo tenga puede leer el archivo.

  1. file send escribe el archivo como un blob en un log nuevo de kolo-store, bajo una clave de archivo nueva, e imprime un código para compartir.
  2. Copias el código al otro terminal: la dirección y la clave del emisor, el ID del log, una semilla para la identidad del receptor, el ID del blob y la clave del archivo.
  3. file get convierte la semilla en su identidad y se conecta con kolo-secure, que comprueba que el otro lado tiene la clave del emisor.
  4. kolo-sync copia el log. El emisor solo lo sirve a la identidad del código, y cada entrada se comprueba contra el head firmado del emisor.
  5. kolo-blobs abre el blob con el ID y la clave del código y comprueba cada fragmento mientras guarda el archivo. Un archivo que falla una comprobación se borra.

Crea una carpeta llamada file dentro de kolo-share, crea en ella un archivo llamado main.go y pega este programa. Tiene dos comandos: send FILE guarda el archivo y lo sirve, y get CODE OUT lo trae con el código para compartir y lo guarda como OUT.

file/main.go
// Command file shares one file between two peers with kolo-blobs.
//
//	file send FILE      stores FILE as a blob, prints a share code and serves the blob
//	file get CODE OUT   fetches the blob with the code, checks every chunk and saves it as OUT
package main

import (
	"bufio"
	"context"
	"crypto/ed25519"
	"crypto/rand"
	"crypto/sha256"
	"encoding/base64"
	"encoding/binary"
	"errors"
	"flag"
	"fmt"
	"io"
	"io/fs"
	"log"
	"net/netip"
	"os"
	"os/signal"
	"path/filepath"
	"strings"
	"sync"
	"syscall"
	"time"

	koloblobs "github.com/ciranda-dev/kolo-blobs"
	koloid "github.com/ciranda-dev/kolo-id"
	kololog "github.com/ciranda-dev/kolo-log"
	kolosecure "github.com/ciranda-dev/kolo-secure"
	kolostore "github.com/ciranda-dev/kolo-store"
	kolosync "github.com/ciranda-dev/kolo-sync"
)

const dialTimeout = 10 * time.Second

func main() {
	listen := flag.String("listen", "127.0.0.1:0", "IPv4 IP:PORT that send listens on; the share code carries it")
	maxBytes := flag.Int64("max-bytes", 1<<30, "most bytes get stores for a file")
	flag.Usage = func() {
		fmt.Fprintln(os.Stderr, "usage: file [-listen IP:PORT] send FILE\n       file [-max-bytes N] get CODE OUT   (CODE - reads the code from standard input)")
		flag.PrintDefaults()
	}
	flag.Parse()
	if *maxBytes <= 0 {
		flag.Usage()
		os.Exit(2)
	}
	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM, syscall.SIGHUP)
	defer stop()
	log.SetFlags(log.Ltime)

	var err error
	switch args := flag.Args(); {
	case len(args) == 2 && args[0] == "send":
		err = send(ctx, *listen, args[1])
	case len(args) == 3 && args[0] == "get":
		err = get(ctx, args[1], args[2], *maxBytes)
	default:
		flag.Usage()
		os.Exit(2)
	}
	if err != nil && ctx.Err() == nil {
		log.Fatal(err)
	}
}

// send stores the file as a blob in a new log and serves that log to whoever holds the share code.
func send(ctx context.Context, listen, name string) error {
	addr, err := netip.ParseAddrPort(listen)
	if err != nil || !addr.Addr().Is4() || addr.Addr().IsUnspecified() {
		return fmt.Errorf("-listen needs an IPv4 address the receiver can reach, such as 127.0.0.1:0, not %q", listen)
	}
	f, err := os.Open(name)
	if err != nil {
		return err
	}
	defer f.Close()
	if info, err := f.Stat(); err != nil {
		return err
	} else if !info.Mode().IsRegular() {
		return fmt.Errorf("%s is not a regular file", name)
	}

	st, _, cleanup, err := openStore()
	if err != nil {
		return err
	}
	defer cleanup()
	me, err := koloid.Generate()
	if err != nil {
		return err
	}
	l, err := st.Create(me)
	if err != nil {
		return err
	}
	key := koloblobs.NewKey()
	sum := sha256.New()
	id, err := koloblobs.New(koloblobs.NewLogBackend(l)).Write(ctx, key, io.TeeReader(f, sum))
	if err != nil {
		return fmt.Errorf("store %s: %w", name, err)
	}
	log.Printf("stored %s as blob %s in %d log entries", name, id.String()[:16], l.Len())
	log.Printf("sha256 %x", sum.Sum(nil))

	// The receiver's identity comes from a seed in the share code, so only the code's holder gets the log.
	var seed [32]byte
	rand.Read(seed[:])
	reader, err := koloid.FromSeed(seed[:])
	if err != nil {
		return err
	}
	srv := kolosync.NewServer(func(peer, _ ed25519.PublicKey, _ kololog.LogID) kolosync.Access {
		if peer.Equal(reader.PublicKey()) {
			return kolosync.Keys
		}
		return kolosync.NoAccess
	})
	if err := srv.Offer(l); err != nil {
		return err
	}
	ln, err := kolosecure.Listen(ctx, addr.String(), me, nil)
	if err != nil {
		return err
	}
	defer ln.Close()
	if addr, err = netip.ParseAddrPort(ln.Addr().String()); err != nil { // the port the system chose
		return err
	}

	c := shareCode{addr: addr, sender: me.PublicKey(), log: l.ID(), seed: seed, blob: id, key: key}
	fmt.Printf("share code:\n%s\n", c)
	log.Print("waiting for the receiver, press Ctrl-C to stop")
	var wg sync.WaitGroup
	defer wg.Wait()
	ctx, cancel := context.WithCancel(ctx) // ends the connections below whenever send returns
	defer cancel()
	for {
		conn, err := ln.Accept(ctx)
		if err != nil {
			return err
		}
		log.Printf("peer %x connected", conn.RemotePublicKey()[:4])
		wg.Go(func() {
			defer conn.Close()
			srv.Serve(ctx, conn)
			log.Printf("peer %x left", conn.RemotePublicKey()[:4])
		})
	}
}

// get copies the sender's log, then reads the blob from it and saves it, checking every chunk on the way.
// It stops with errTooBig when the copy would hold more than maxBytes.
func get(ctx context.Context, code, out string, maxBytes int64) error {
	code, err := readCode(code)
	if err != nil {
		return err
	}
	c, err := parseCode(code)
	if err != nil {
		return err
	}
	if _, err := os.Lstat(out); err == nil {
		return fmt.Errorf("%s already exists; choose a new name", out)
	}
	me, err := koloid.FromSeed(c.seed[:])
	if err != nil {
		return err
	}
	st, dir, cleanup, err := openStore()
	if err != nil {
		return err
	}
	defer cleanup()

	dctx, cancel := context.WithTimeout(ctx, dialTimeout)
	defer cancel()
	conn, err := kolosecure.Dial(dctx, c.addr.String(), me, c.sender, nil)
	if err != nil {
		return fmt.Errorf("cannot reach the sender at %s: %w", c.addr, err)
	}
	defer conn.Close()
	header, err := kolosync.FetchHeader(ctx, conn, c.sender, c.log)
	if errors.Is(err, kolosync.ErrNotFound) {
		return fmt.Errorf("the sender does not share this file with this code: %w", err)
	} else if err != nil {
		return fmt.Errorf("ask the sender for its log: %w", err)
	}
	rep, err := st.OpenReplica(c.sender, c.log, header)
	if err != nil {
		return err
	}
	log.Print("downloading")
	lctx, stopLimit := limit(ctx, dir, maxBytes)
	defer stopLimit()
	if err := kolosync.Pull(lctx, conn, rep); err != nil {
		return fmt.Errorf("download: %w", tooBig(lctx, err))
	}
	log.Printf("received %d log entries, each checked against the sender's signed head", rep.Len())

	r, err := koloblobs.New(koloblobs.NewLogBackend(rep)).Open(ctx, c.blob, c.key)
	if err != nil {
		return explain(err)
	}
	defer r.Close()
	if r.Size() > maxBytes {
		return errTooBig
	}
	f, err := os.OpenFile(out, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o600) // never replaces a file
	if err != nil {
		return err
	}
	sum := sha256.New()
	_, err = io.Copy(io.MultiWriter(f, sum), r)
	if cerr := f.Close(); err == nil {
		err = cerr
	}
	if err != nil {
		os.Remove(out) // no half-written or unverified file is left behind
		return explain(err)
	}
	log.Printf("saved %s: %d bytes, every chunk checked against the blob ID", out, r.Size())
	log.Printf("sha256 %x", sum.Sum(nil))
	return nil
}

// explain turns the errors of kolo-blobs into a sentence a user can act on.
func explain(err error) error {
	switch {
	case errors.Is(err, koloblobs.ErrWrongKey):
		return fmt.Errorf("the key in the share code does not open this file: %w", err)
	case errors.Is(err, koloblobs.ErrCorrupt):
		return fmt.Errorf("the file failed verification, nothing was saved: %w", err)
	case errors.Is(err, koloblobs.ErrNotFound):
		return fmt.Errorf("the sender's log does not hold this file: %w", err)
	}
	return err
}

// openStore opens a kolo-store in a new temporary folder, removed by the returned function.
func openStore() (*kolostore.Store, string, func(), error) {
	dir, err := os.MkdirTemp("", "kolo-share-")
	if err != nil {
		return nil, "", nil, err
	}
	db, err := kolostore.OpenPebble(dir)
	if err != nil {
		os.RemoveAll(dir)
		return nil, "", nil, err
	}
	st := kolostore.New(db)
	return st, dir, func() {
		st.Close()
		os.RemoveAll(dir)
	}, nil
}

// errTooBig ends a get that would store more than -max-bytes.
var errTooBig = errors.New("the sender offers more than -max-bytes allows; only get codes from people you trust")

// limit returns a context that ends with errTooBig once the folder dir holds more than max bytes.
func limit(ctx context.Context, dir string, max int64) (context.Context, context.CancelFunc) {
	ctx, cancel := context.WithCancelCause(ctx)
	go func() {
		for {
			select {
			case <-ctx.Done():
				return
			case <-time.After(250 * time.Millisecond):
			}
			var n int64
			filepath.WalkDir(dir, func(_ string, d fs.DirEntry, err error) error {
				if err != nil || d.IsDir() {
					return nil
				}
				if info, err := d.Info(); err == nil {
					n += info.Size()
				}
				return nil
			})
			if n > max {
				cancel(errTooBig)
				return
			}
		}
	}()
	return ctx, func() { cancel(nil) }
}

// tooBig returns errTooBig when ctx ended because of limit, and err otherwise.
func tooBig(ctx context.Context, err error) error {
	if errors.Is(context.Cause(ctx), errTooBig) {
		return errTooBig
	}
	return err
}

// readCode returns code, or the first line of standard input when code is "-", so that it stays out of ps and the shell history.
func readCode(code string) (string, error) {
	if code != "-" {
		return code, nil
	}
	line, _ := bufio.NewReader(io.LimitReader(os.Stdin, 4096)).ReadString('\n')
	if line == "" {
		return "", errors.New("no share code on standard input")
	}
	return line, nil
}

// checkAddr refuses the addresses nobody can listen on, so that a share code cannot make get send packets to them.
func checkAddr(a netip.AddrPort) bool {
	ip := a.Addr()
	return a.Port() != 0 && !ip.IsUnspecified() && !ip.IsMulticast() && ip != netip.AddrFrom4([4]byte{255, 255, 255, 255})
}

// shareCode is all the receiver needs: where the sender listens, its public key, the log holding the blob,
// the seed of the receiver's identity, and the blob's ID and key. Whoever has it can read the file.
type shareCode struct {
	addr   netip.AddrPort
	sender ed25519.PublicKey
	log    kololog.LogID
	seed   [32]byte
	blob   koloblobs.ID
	key    koloblobs.Key
}

const (
	codePrefix = "kolo-file:"
	codeSize   = 6 + 32 + kololog.LogIDSize + 32 + koloblobs.HashSize + koloblobs.KeySize
)

func (c shareCode) String() string {
	ip := c.addr.Addr().As4()
	b := binary.BigEndian.AppendUint16(ip[:], c.addr.Port())
	b = append(b, c.sender...)
	b = append(b, c.log[:]...)
	b = append(b, c.seed[:]...)
	b = append(b, c.blob[:]...)
	b = append(b, c.key[:]...)
	return codePrefix + base64.RawURLEncoding.EncodeToString(b)
}

func parseCode(s string) (shareCode, error) {
	rest, ok := strings.CutPrefix(strings.TrimSpace(s), codePrefix)
	b, err := base64.RawURLEncoding.DecodeString(rest)
	if !ok || err != nil || len(b) != codeSize {
		return shareCode{}, fmt.Errorf("this is not a file share code; copy the whole line, it starts with %q", codePrefix)
	}
	var c shareCode
	c.addr = netip.AddrPortFrom(netip.AddrFrom4([4]byte(b[:4])), binary.BigEndian.Uint16(b[4:6]))
	if !checkAddr(c.addr) {
		return shareCode{}, fmt.Errorf("the share code names %s, an address nobody can listen on", c.addr)
	}
	b = b[6:]
	c.sender = ed25519.PublicKey(b[:32])
	b = b[32:]
	b = b[copy(c.log[:], b):]
	b = b[copy(c.seed[:], b):]
	b = b[copy(c.blob[:], b):]
	copy(c.key[:], b)
	return c, nil
}

Qué hace cada parte:

  • send crea una identidad nueva para esta ejecución con koloid.Generate y un log de kolo-store en una carpeta temporal nueva (openStore), que se borra cuando el programa se detiene.
  • koloblobs.NewKey crea una clave aleatoria para este archivo, y Write corta el archivo en fragmentos, cifra cada uno y los añade al log como entradas. Devuelve el ID del blob. El programa también calcula el SHA-256 del archivo mientras lo lee, con io.TeeReader, para que puedas compararlo después con la copia.
  • El código para compartir lleva todo lo que necesita el receptor: la dirección y la clave pública del emisor, el ID del log, el ID del blob, la clave del archivo y una semilla aleatoria. El receptor convierte la semilla en su identidad con koloid.FromSeed. El servidor de kolo-sync da acceso con Keys solo a esa identidad, así que un peer sin el código no obtiene nada.
  • get se conecta con kolosecure.Dial, que comprueba que el otro lado tiene la clave del emisor. kolosync.FetchHeader y OpenReplica crean una copia local del log del emisor, y kolosync.Pull la llena, comprobando cada entrada contra el head firmado del emisor.
  • Open comprueba la raíz del blob contra el ID y la clave, e io.Copy lee el archivo fragmento a fragmento; cada fragmento se comprueba contra el árbol antes de escribir sus bytes. Si algo falla, el programa borra el archivo de salida, también cuando lo interrumpes, así que nunca queda un archivo a medio escribir o sin comprobar. El archivo se crea con modo 0600: solo tú puedes leerlo.
  • get también se protege de un código que viene de otra persona. Se detiene con the sender offers more than -max-bytes allows; only get codes from people you trust cuando lo que descarga (el almacén temporal) o lo que escribe supera -max-bytes, 1 GiB por defecto (por ejemplo go run ./file -max-bytes 100000000 get CODE copy.jpg). Un código que nombra 0.0.0.0, una dirección multicast, la de broadcast o el puerto 0 se rechaza (the share code names ADDR, an address nobody can listen on). Un código es una dirección más un secreto, así que usa solo códigos de personas de confianza. El código se puede leer de la entrada estándar con -, para que no aparezca en ps ni en el historial del shell: echo CODE | go run ./file get - copy.txt.
  • explain convierte los errores de kolo-blobs en frases: una clave incorrecta (ErrWrongKey), un objeto que falla una comprobación (ErrCorrupt) o uno que falta (ErrNotFound).
  • -listen es la dirección en la que escucha el emisor, 127.0.0.1:0 por defecto: solo tu ordenador, en un puerto que elige el sistema. El código lleva esa dirección, así que debe ser una dirección IPv4 a la que el receptor pueda llegar.

5Crea un archivo para compartir

En el Terminal 1, en la carpeta kolo-share, crea un archivo de texto pequeño:

bash
echo "hello from terminal 1" > hello.txt

Sirve cualquier archivo: una foto, un vídeo, un archivo comprimido. Un archivo de cualquier tamaño se guarda en tantos fragmentos como necesite.

6Compártelo desde el Terminal 1

En el Terminal 1, ejecuta:

Terminal
go run ./file send hello.txt

La primera vez tarda un momento en compilar. Después guarda el archivo, imprime su SHA-256 y el código para compartir, y espera. Tus horas, IDs, hash y código serán distintos:

Texto
21:06:38 stored hello.txt as blob a9d85e576f8d1489 in 2 log entries
21:06:38 sha256 2b3bbe311b98a8d367296b62fcb806cb076ccddb893f9f02dbd0c327c98e2385
share code:
kolo-file:fwAAAfOct7bUTbr73o5USjYMV_QoCysEQPbcwAuLL6DkJGdBSUQglI3Xz74siUO8VhQOnKqBB_BVw5FKd-VlHrXEjaeUYdYkEK2038sz_yilgROh560Mz7emkvCv0wzsYlDWEg5KqdheV2-NFImL7UW_f-0M4Q-5I9a4D2Tiy1BSEnQPJUFePQEC6hq_trv_ybEglewb2IyH6o9exzlkNklfTSSOAw
21:06:38 waiting for the receiver, press Ctrl-C to stop

Un archivo pequeño ocupa 2 entradas del log: un fragmento y la raíz de su árbol. Selecciona la línea entera que empieza por kolo-file: y cópiala. Deja el Terminal 1 en marcha.

7Recíbelo en el Terminal 2

En el Terminal 2, ve a la misma carpeta kolo-share (usa la ruta donde la creaste):

Terminal
cd kolo-share

Después ejecuta get con el código que copiaste, entre comillas simples, y un nombre para la copia:

Terminal
go run ./file get '<share code>' copy.txt

Sustituye <share code> por el código entero, incluido kolo-file:. El Terminal 2 imprime:

Texto
21:06:38 downloading
21:06:38 received 2 log entries, each checked against the sender's signed head
21:06:38 saved copy.txt: 22 bytes, every chunk checked against the blob ID
21:06:38 sha256 2b3bbe311b98a8d367296b62fcb806cb076ccddb893f9f02dbd0c327c98e2385

Y el Terminal 1 muestra cómo llega y se va el receptor, con el nombre de su clave:

Texto
21:06:38 peer db309a79 connected
21:06:38 peer db309a79 left

8Comprueba que la copia es igual

El programa ya comprobó cada fragmento contra el ID del blob, y las dos líneas sha256, una en cada terminal, son iguales. También puedes pedirle a tu sistema el SHA-256 de los dos archivos, en el Terminal 2:

bash
shasum -a 256 hello.txt copy.txt

Las dos líneas llevan el mismo hash:

Texto
2b3bbe311b98a8d367296b62fcb806cb076ccddb893f9f02dbd0c327c98e2385  hello.txt
2b3bbe311b98a8d367296b62fcb806cb076ccddb893f9f02dbd0c327c98e2385  copy.txt

Get-FileHash en Windows imprime una tabla con el hash en mayúsculas. Allí, Set-Content también termina la línea con dos caracteres, así que el archivo tiene 23 bytes y otro hash; los dos archivos siguen coincidiendo entre sí.

9Mira qué pasa cuando algo falla

Vuelve a ejecutar get con el mismo nombre. Nunca sustituye un archivo, y borra el archivo parcial cuando falla o lo interrumpes:

Terminal
go run ./file get '<share code>' copy.txt
Texto
21:06:39 copy.txt already exists; choose a new name
exit status 1

La última línea viene de go run: el programa terminó con un error. Ahora dale algo que no es un código:

Terminal
go run ./file get 'kolo-file:abc' other.txt
Texto
21:06:39 this is not a file share code; copy the whole line, it starts with "kolo-file:"
exit status 1

Pulsa Ctrl-C en el Terminal 1 para detener el emisor y luego ejecuta get una vez más con el código real y un nombre nuevo, en el Terminal 2:

Terminal
go run ./file get '<share code>' late.txt

Al cabo de unos segundos:

Texto
21:06:53 cannot reach the sender at 127.0.0.1:62364: kolotransport: timeout
exit status 1

late.txt no se crea. Un código con la clave cambiada falla con the key in the share code does not open this file, y uno con la semilla cambiada, con the sender does not share this file with this code: los tests del repositorio comprueban los dos casos.

10Escribe el programa que comparte una carpeta

El segundo programa comparte una carpeta con kolo-files. La carpeta se convierte en un volumen: un log de metadatos con una op por cambio y un log de contenido que guarda el contenido de cada archivo como un blob de kolo-blobs. Cada op es una versión nueva.

Todos los pasos

Una carpeta y sus versiones

El receptor guarda cada versión en una carpeta propia, así que las versiones anteriores se quedan como estaban.

  1. folder send mete cada archivo y cada carpeta en un volumen nuevo de kolo-files e imprime un código para compartir. El código no lleva ninguna clave de archivo: las claves viajan dentro del log de metadatos.
  2. Copias el código al otro terminal: la dirección y la clave del emisor, el ID del log de metadatos y una semilla para la identidad del receptor.
  3. folder get copia el log de metadatos, encuentra el log de contenido en su primera entrada y lo copia también, y luego guarda el volumen con os.CopyFS en OUT/v y el número de versión, como OUT/v5.
  4. Pulsa Intro en el Terminal 1: los archivos y carpetas nuevos se convierten en ops CREATE y MKDIR, los archivos cambiados en ops WRITE y los borrados en ops REMOVE y PURGE. Cada op es una versión nueva.
  5. Cada 2 segundos el receptor copia solo las entradas nuevas, refresca el volumen, imprime el Diff entre la versión guardada y la nueva, y guarda la nueva.

Crea una carpeta llamada folder dentro de kolo-share, crea en ella main.go y pega este programa:

folder/main.go
// Command folder shares a folder between two peers with kolo-files and keeps the copy up to date.
//
//	folder send DIR    puts DIR in a volume, prints a share code and publishes changes each time you press Enter
//	folder get CODE OUT   saves the folder into OUT/v<version>, then each new version the sender publishes
package main

import (
	"bufio"
	"context"
	"crypto/ed25519"
	"crypto/rand"
	"encoding/base64"
	"encoding/binary"
	"errors"
	"flag"
	"fmt"
	"io"
	"io/fs"
	"log"
	"net/netip"
	"os"
	"os/signal"
	"path/filepath"
	"strings"
	"sync"
	"syscall"
	"time"

	koloblobs "github.com/ciranda-dev/kolo-blobs"
	kolofiles "github.com/ciranda-dev/kolo-files"
	koloid "github.com/ciranda-dev/kolo-id"
	kololog "github.com/ciranda-dev/kolo-log"
	kolosecure "github.com/ciranda-dev/kolo-secure"
	kolostore "github.com/ciranda-dev/kolo-store"
	kolosync "github.com/ciranda-dev/kolo-sync"
)

const dialTimeout = 10 * time.Second

func main() {
	listen := flag.String("listen", "127.0.0.1:0", "IPv4 IP:PORT that send listens on; the share code carries it")
	every := flag.Duration("every", 2*time.Second, "how often get asks the sender for a new version")
	maxBytes := flag.Int64("max-bytes", 1<<30, "most bytes get stores, and writes into OUT in all")
	flag.Usage = func() {
		fmt.Fprintln(os.Stderr, "usage: folder [-listen IP:PORT] send DIR\n       folder [-every 2s] [-max-bytes N] get CODE OUT   (CODE - reads the code from standard input)")
		flag.PrintDefaults()
	}
	flag.Parse()
	if *every <= 0 || *maxBytes <= 0 {
		flag.Usage()
		os.Exit(2)
	}
	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM, syscall.SIGHUP)
	defer stop()
	log.SetFlags(log.Ltime)

	var err error
	switch args := flag.Args(); {
	case len(args) == 2 && args[0] == "send":
		err = send(ctx, *listen, args[1])
	case len(args) == 3 && args[0] == "get":
		err = get(ctx, args[1], args[2], *every, *maxBytes)
	default:
		flag.Usage()
		os.Exit(2)
	}
	if err != nil && ctx.Err() == nil {
		log.Fatal(err)
	}
}

// send keeps dir in a volume, serves its two logs to whoever holds the share code and adds a version on Enter.
func send(ctx context.Context, listen, dir string) error {
	addr, err := netip.ParseAddrPort(listen)
	if err != nil || !addr.Addr().Is4() || addr.Addr().IsUnspecified() {
		return fmt.Errorf("-listen needs an IPv4 address the receiver can reach, such as 127.0.0.1:0, not %q", listen)
	}
	if info, err := os.Lstat(dir); err != nil {
		return err
	} else if !info.IsDir() {
		return fmt.Errorf("%s is not a folder", dir)
	}
	st, _, cleanup, err := openStore()
	if err != nil {
		return err
	}
	defer cleanup()
	me, err := koloid.Generate()
	if err != nil {
		return err
	}
	meta, err := st.Create(me)
	if err != nil {
		return err
	}
	content, err := st.Create(me)
	if err != nil {
		return err
	}
	v, err := kolofiles.Create(meta, content)
	if err != nil {
		return err
	}
	defer v.Close()
	seen := map[string]stamp{}
	if err := update(ctx, v, dir, seen); err != nil {
		return err
	}
	log.Printf("version %d holds %s", v.Len(), dir)

	var seed [32]byte
	rand.Read(seed[:])
	reader, err := koloid.FromSeed(seed[:])
	if err != nil {
		return err
	}
	srv := kolosync.NewServer(func(peer, _ ed25519.PublicKey, _ kololog.LogID) kolosync.Access {
		if peer.Equal(reader.PublicKey()) {
			return kolosync.Keys
		}
		return kolosync.NoAccess
	})
	for _, l := range []*kolostore.Log{meta, content} {
		if err := srv.Offer(l); err != nil {
			return err
		}
	}
	ln, err := kolosecure.Listen(ctx, addr.String(), me, nil)
	if err != nil {
		return err
	}
	defer ln.Close()
	if addr, err = netip.ParseAddrPort(ln.Addr().String()); err != nil { // the port the system chose
		return err
	}

	c := shareCode{addr: addr, sender: me.PublicKey(), meta: v.ID(), seed: seed}
	fmt.Printf("share code:\n%s\n", c)
	log.Print("change files in the folder, then press Enter to publish them; Ctrl-C stops")
	var wg sync.WaitGroup
	defer wg.Wait()
	ctx, cancel := context.WithCancel(ctx) // ends the goroutines below whenever send returns
	defer cancel()
	wg.Go(func() {
		for {
			conn, err := ln.Accept(ctx)
			if err != nil {
				return
			}
			log.Printf("peer %x connected", conn.RemotePublicKey()[:4])
			wg.Go(func() {
				defer conn.Close()
				srv.Serve(ctx, conn)
				log.Printf("peer %x left", conn.RemotePublicKey()[:4])
			})
		}
	})
	enter := make(chan struct{})
	go func() {
		sc := bufio.NewScanner(os.Stdin)
		for sc.Scan() {
			enter <- struct{}{}
		}
	}()
	for {
		select {
		case <-ctx.Done():
			return nil
		case <-enter:
			before := v.Len()
			if err := update(ctx, v, dir, seen); err != nil {
				return err
			}
			if v.Len() == before {
				log.Print("nothing changed")
			} else {
				log.Printf("published version %d", v.Len())
			}
		}
	}
}

// stamp is what update compares to find a changed file: its size and modification time.
type stamp struct {
	dir  bool
	size int64
	mod  time.Time
}

// update makes the volume match dir: it adds new folders and files, writes changed files and deletes what is gone.
// seen holds the stamps of the last update and is brought up to date.
func update(ctx context.Context, v *kolofiles.Volume, dir string, seen map[string]stamp) error {
	now := map[string]stamp{}
	err := filepath.WalkDir(dir, func(p string, d fs.DirEntry, err error) error {
		if errors.Is(err, fs.ErrNotExist) && p != dir {
			return nil // removed while we walked: the next update sees it gone
		}
		if err != nil || p == dir {
			return err
		}
		if !d.IsDir() && !d.Type().IsRegular() {
			return nil // links and devices are not shared
		}
		rel, err := filepath.Rel(dir, p)
		if err != nil {
			return err
		}
		name := filepath.ToSlash(rel)
		info, err := d.Info()
		if errors.Is(err, fs.ErrNotExist) {
			return nil
		} else if err != nil {
			return err
		}
		s := stamp{dir: true}
		if !d.IsDir() {
			s = stamp{size: info.Size(), mod: info.ModTime()}
		}
		old, ok := seen[name]
		if ok && old.dir != s.dir { // a file became a folder or the other way round
			if err := v.Delete(name); err != nil {
				return err
			}
			ok = false
		}
		switch {
		case ok && (s.dir || old == s):
		case s.dir:
			err = v.Mkdir(name)
		default:
			var f *os.File
			if f, err = os.Open(p); err == nil {
				err = v.WriteFile(ctx, name, f)
				f.Close()
			}
		}
		if err != nil {
			log.Printf("skipped %s: %v", name, err)
			if ok {
				now[name] = old // keep the published version; the next update tries again
			}
			if s.dir {
				return fs.SkipDir
			}
			return nil
		}
		now[name] = s
		return nil
	})
	if err != nil {
		return err
	}
	for name := range seen {
		if _, ok := now[name]; !ok {
			// A folder's delete takes everything below it, so a later delete of a child finds nothing,
			// or finds a file where its folder was.
			if err := v.Delete(name); err != nil && !errors.Is(err, fs.ErrNotExist) && !errors.Is(err, kolofiles.ErrNotDir) {
				return err
			}
		}
	}
	clear(seen)
	for name, s := range now {
		seen[name] = s
	}
	return nil
}

// get copies the sender's two logs, saves the folder, then pulls again every few seconds and saves each new version.
// It stops with errTooBig when the copy, or all the versions saved in out together, would hold more than maxBytes.
func get(ctx context.Context, code, out string, every time.Duration, maxBytes int64) error {
	code, err := readCode(code)
	if err != nil {
		return err
	}
	c, err := parseCode(code)
	if err != nil {
		return err
	}
	if _, err := os.Lstat(out); err == nil {
		return fmt.Errorf("%s already exists; choose a new name", out)
	}
	me, err := koloid.FromSeed(c.seed[:])
	if err != nil {
		return err
	}
	st, dir, cleanup, err := openStore()
	if err != nil {
		return err
	}
	defer cleanup()
	dctx, cancel := context.WithTimeout(ctx, dialTimeout)
	defer cancel()
	conn, err := kolosecure.Dial(dctx, c.addr.String(), me, c.sender, nil)
	if err != nil {
		return fmt.Errorf("cannot reach the sender at %s: %w", c.addr, err)
	}
	defer conn.Close()

	lctx, stopLimit := limit(ctx, dir, maxBytes)
	defer stopLimit()
	meta, err := replica(lctx, st, conn, c.sender, c.meta)
	if err != nil {
		return err
	}
	contentID, err := kolofiles.ContentLog(meta)
	if err != nil {
		return err
	}
	content, err := replica(lctx, st, conn, c.sender, contentID)
	if err != nil {
		return err
	}
	v, err := kolofiles.OpenReader(meta, koloblobs.NewLogBackend(content), nil)
	if err != nil {
		return err
	}
	defer v.Close()

	if err := os.MkdirAll(out, 0o700); err != nil { // the folders inside are private too
		return err
	}
	var saved uint64
	var written int64
	defer func() {
		if saved == 0 {
			os.Remove(out) // leaves nothing behind when no version was saved
		}
	}()
	for {
		if n := v.Len(); n > saved {
			if saved > 0 {
				changes, err := v.Diff(saved, n)
				if err != nil {
					return err
				}
				printChanges(changes)
			}
			size, err := treeSize(v)
			if err != nil {
				return err
			}
			if written += size; written > maxBytes {
				return errTooBig
			}
			dst := filepath.Join(out, fmt.Sprintf("v%d", n))
			if err := os.CopyFS(dst, v); err != nil {
				os.RemoveAll(dst) // no half-saved version is left behind
				return fmt.Errorf("save version %d: %w", n, err)
			}
			log.Printf("saved version %d in %s, every file checked against its blob ID", n, dst)
			saved = n
		}
		select {
		case <-ctx.Done():
			return nil
		case <-time.After(every):
		}
		// The metadata first: content pulled after it holds every object its ops name.
		if err := kolosync.Pull(lctx, conn, meta); err != nil {
			return fmt.Errorf("lost the sender: %w", tooBig(lctx, err))
		}
		if err := kolosync.Pull(lctx, conn, content); err != nil {
			return fmt.Errorf("lost the sender: %w", tooBig(lctx, err))
		}
		if err := v.Refresh(); err != nil {
			return err
		}
	}
}

// treeSize adds up the sizes of the files in fsys.
func treeSize(fsys fs.FS) (n int64, err error) {
	err = fs.WalkDir(fsys, ".", func(_ string, d fs.DirEntry, err error) error {
		if err != nil || d.IsDir() {
			return err
		}
		info, err := d.Info()
		if err == nil {
			n += info.Size()
		}
		return err
	})
	return n, err
}

// replica opens a local replica of the sender's log logID and pulls it.
func replica(ctx context.Context, st *kolostore.Store, conn *kolosecure.Conn, owner ed25519.PublicKey, logID kololog.LogID) (*kolostore.Replica, error) {
	header, err := kolosync.FetchHeader(ctx, conn, owner, logID)
	if errors.Is(err, kolosync.ErrNotFound) {
		return nil, fmt.Errorf("the sender does not share this folder with this code: %w", err)
	} else if err != nil {
		return nil, fmt.Errorf("ask the sender for its log: %w", err)
	}
	rep, err := st.OpenReplica(owner, logID, header)
	if err != nil {
		return nil, err
	}
	if err := kolosync.Pull(ctx, conn, rep); err != nil {
		return nil, fmt.Errorf("download: %w", err)
	}
	return rep, nil
}

// printChanges prints what Diff found between two versions.
func printChanges(changes []kolofiles.Change) {
	for _, c := range changes {
		switch {
		case c.Deleted:
			log.Print("  deleted a file or folder (its names are gone with it)")
		case c.Old == "":
			log.Printf("  added %s", c.New)
		case c.Old != c.New && c.Modified:
			log.Printf("  moved %s to %s and changed it", c.Old, c.New)
		case c.Old != c.New:
			log.Printf("  moved %s to %s", c.Old, c.New)
		default:
			log.Printf("  changed %s", c.New)
		}
	}
}

// openStore opens a kolo-store in a new temporary folder, removed by the returned function.
func openStore() (*kolostore.Store, string, func(), error) {
	dir, err := os.MkdirTemp("", "kolo-share-")
	if err != nil {
		return nil, "", nil, err
	}
	db, err := kolostore.OpenPebble(dir)
	if err != nil {
		os.RemoveAll(dir)
		return nil, "", nil, err
	}
	st := kolostore.New(db)
	return st, dir, func() {
		st.Close()
		os.RemoveAll(dir)
	}, nil
}

// errTooBig ends a get that would store more than -max-bytes.
var errTooBig = errors.New("the sender offers more than -max-bytes allows; only get codes from people you trust")

// limit returns a context that ends with errTooBig once the folder dir holds more than max bytes.
func limit(ctx context.Context, dir string, max int64) (context.Context, context.CancelFunc) {
	ctx, cancel := context.WithCancelCause(ctx)
	go func() {
		for {
			select {
			case <-ctx.Done():
				return
			case <-time.After(250 * time.Millisecond):
			}
			var n int64
			filepath.WalkDir(dir, func(_ string, d fs.DirEntry, err error) error {
				if err != nil || d.IsDir() {
					return nil
				}
				if info, err := d.Info(); err == nil {
					n += info.Size()
				}
				return nil
			})
			if n > max {
				cancel(errTooBig)
				return
			}
		}
	}()
	return ctx, func() { cancel(nil) }
}

// tooBig returns errTooBig when ctx ended because of limit, and err otherwise.
func tooBig(ctx context.Context, err error) error {
	if errors.Is(context.Cause(ctx), errTooBig) {
		return errTooBig
	}
	return err
}

// readCode returns code, or the first line of standard input when code is "-", so that it stays out of ps and the shell history.
func readCode(code string) (string, error) {
	if code != "-" {
		return code, nil
	}
	line, _ := bufio.NewReader(io.LimitReader(os.Stdin, 4096)).ReadString('\n')
	if line == "" {
		return "", errors.New("no share code on standard input")
	}
	return line, nil
}

// checkAddr refuses the addresses nobody can listen on, so that a share code cannot make get send packets to them.
func checkAddr(a netip.AddrPort) bool {
	ip := a.Addr()
	return a.Port() != 0 && !ip.IsUnspecified() && !ip.IsMulticast() && ip != netip.AddrFrom4([4]byte{255, 255, 255, 255})
}

// shareCode is all the receiver needs: where the sender listens, its public key, the volume's metadata log and
// the seed of the receiver's identity. The file keys travel inside the metadata log. Whoever has it can read the folder.
type shareCode struct {
	addr   netip.AddrPort
	sender ed25519.PublicKey
	meta   kololog.LogID
	seed   [32]byte
}

const (
	codePrefix = "kolo-folder:"
	codeSize   = 6 + 32 + kololog.LogIDSize + 32
)

func (c shareCode) String() string {
	ip := c.addr.Addr().As4()
	b := binary.BigEndian.AppendUint16(ip[:], c.addr.Port())
	b = append(b, c.sender...)
	b = append(b, c.meta[:]...)
	b = append(b, c.seed[:]...)
	return codePrefix + base64.RawURLEncoding.EncodeToString(b)
}

func parseCode(s string) (shareCode, error) {
	rest, ok := strings.CutPrefix(strings.TrimSpace(s), codePrefix)
	b, err := base64.RawURLEncoding.DecodeString(rest)
	if !ok || err != nil || len(b) != codeSize {
		return shareCode{}, fmt.Errorf("this is not a folder share code; copy the whole line, it starts with %q", codePrefix)
	}
	var c shareCode
	c.addr = netip.AddrPortFrom(netip.AddrFrom4([4]byte(b[:4])), binary.BigEndian.Uint16(b[4:6]))
	if !checkAddr(c.addr) {
		return shareCode{}, fmt.Errorf("the share code names %s, an address nobody can listen on", c.addr)
	}
	b = b[6:]
	c.sender = ed25519.PublicKey(b[:32])
	b = b[32:]
	b = b[copy(c.meta[:], b):]
	copy(c.seed[:], b)
	return c, nil
}

Qué hay de nuevo respecto al primer programa:

  • send crea dos logs y kolofiles.Create hace un volumen con ellos. update recorre la carpeta: llama a Mkdir por cada carpeta nueva, a WriteFile por cada archivo nuevo o cambiado y a Delete por lo que ya no está. Un archivo cuenta como cambiado cuando su tamaño o su hora de modificación no son los de la pasada anterior, porque WriteFile siempre añade una versión, aunque el contenido sea el mismo.
  • Cada vez que pulsas Intro, update se vuelve a ejecutar y el emisor imprime la versión nueva, o nothing changed.
  • El código para compartir es más corto: solo nombra el log de metadatos. Las claves de los archivos están dentro de ese log, cifradas por kolo-log, y viajan con él.
  • get hace pull del log de metadatos, encuentra el log de contenido con kolofiles.ContentLog y también hace pull de él, y luego abre el volumen con OpenReader. Un Volume es un sistema de archivos io/fs, así que os.CopyFS lo guarda en disco, y cada archivo que lee se comprueba contra su ID de blob. Como el primer programa, rechaza un OUT que ya existe y borra una versión que no pudo guardar entera. OUT y las carpetas que contiene se crean con modo 0700, así que solo tú puedes leerlas.
  • get se detiene con the sender offers more than -max-bytes allows; only get codes from people you trust cuando lo que descarga, o todas las versiones que escribió en OUT juntas, superan -max-bytes (1 GiB por defecto; cada versión es una copia completa). El código se puede leer de la entrada estándar con -, y un código que nombra una dirección en la que nadie puede escuchar se rechaza, como en el primer programa.
  • Cada 2 segundos (-every), get vuelve a hacer pull de los dos logs, primero el de metadatos, y llama a Refresh. Cuando la versión ha crecido, Diff enumera lo que ha cambiado y la versión nueva se guarda en una carpeta propia, junto a las anteriores.
  • Este programa compara rutas, así que un archivo renombrado llega al receptor como un borrado y un archivo nuevo. kolo-files tiene Move, que conserva el nodo del archivo y su historial; una app que sabe que un archivo se ha renombrado lo llama.

11Comparte una carpeta y cámbiala

En el Terminal 1, crea una carpeta con unos cuantos archivos:

bash
mkdir -p shared/notes && echo "buy bread" > shared/todo.txt && echo "first draft" > shared/notes/ideas.txt && cp hello.txt shared/

Compártela:

Terminal
go run ./folder send shared
Texto
21:07:02 version 5 holds shared
share code:
kolo-folder:fwAAAdrwpr17aqfOwmDq_IOx4WKK4QJkgD3tpVO6DthM9tPXLrBvR-B9CcWI5GObQ0v95GHhjronYzB1xx6FQDd5z9F-VhVeZaSEJgNRBoAf-ur59bcaY70ePv58tCTZpJtRxOdI
21:07:02 change files in the folder, then press Enter to publish them; Ctrl-C stops

La versión 5 es el volumen vacío más cuatro ops: los archivos hello.txt, todo.txt y notes/ideas.txt, y la carpeta notes. En el Terminal 2, recíbela en una carpeta llamada copy:

Terminal
go run ./folder get '<share code>' copy
Texto
21:07:02 saved version 5 in copy/v5, every file checked against its blob ID

Deja los dos en marcha. Abre una tercera ventana de terminal en la carpeta kolo-share, o usa tu gestor de archivos, y cambia la carpeta compartida: edita un archivo, añade uno y borra otro.

bash
echo "buy bread and milk" > shared/todo.txt && echo "plans for the weekend" > shared/plans.txt && rm shared/hello.txt

Después pulsa Intro en el Terminal 1:

Texto
21:07:06 published version 9

Esta vez son cuatro ops: una op WRITE para todo.txt, una op CREATE para plans.txt, y una op REMOVE y una op PURGE para el archivo borrado. En menos de 2 segundos, el Terminal 2 imprime lo que ha cambiado y guarda la versión nueva:

Texto
21:07:06   deleted a file or folder (its names are gone with it)
21:07:06   added plans.txt
21:07:06   changed todo.txt
21:07:06 saved version 9 in copy/v9, every file checked against its blob ID

copy/v5 sigue teniendo la primera versión, en la que todo.txt dice buy bread, y copy/v9 tiene la carpeta tal como está ahora. Un archivo borrado no muestra ningún nombre en el diff: sus nombres, su clave y su contenido se destruyen con él. Vuelve a pulsar Intro en el Terminal 1 sin cambiar nada, e imprime nothing changed.

12Páralo todo

Pulsa Ctrl-C en el Terminal 1. El emisor se detiene y borra su almacén temporal. El Terminal 2 se da cuenta en su siguiente pull y también se detiene, conservando lo que guardó:

Texto
21:07:18 lost the sender: kolosync: timeout: opening a stream
exit status 1

Entre dos computadoras

Los dos programas se conectan directamente: el código para compartir lleva la dirección IPv4 y el puerto del emisor, y el receptor marca esa dirección. No usan la DHT ni el swarm, así que no hay bootstrap que configurar.

  • En una sola computadora funciona tal cual: -listen vale 127.0.0.1:0 por defecto.
  • En la misma red local, el emisor pasa -listen antes de send, con la dirección IPv4 de su tarjeta de red y un puerto, como -listen 192.168.1.20:7450, y el receptor llega a él con el código. La dirección debe ser IPv4 y no 0.0.0.0; si no, send se detiene con -listen needs an IPv4 address the receiver can reach.
  • Entre dos redes distintas solo funciona si el emisor tiene una dirección IPv4 pública a la que el receptor pueda llegar, con el puerto UDP abierto en el firewall.
  • Dos computadoras que están ambas detrás de routers domésticos no se conectarán: estos programas no atraviesan el NAT y no usan relay.

Para ese caso usa los ejemplos de Kolo (chat, share, meet, board) o la biblioteca kolo-swarm, que encuentran a los pares por los nodos de entrada públicos de forma predeterminada.

Un archivo o una carpeta

Aspectofile (kolo-blobs)folder (kolo-files)
Qué se compartelos bytes de un archivoun árbol de archivos y carpetas, con sus nombres
Qué lleva el códigoel ID del blob y la clave del archivoel ID del log de metadatos; las claves de los archivos viajan dentro de ese log
Un cambioun archivo nuevo es un blob nuevo y un código nuevocada cambio es una versión nueva del mismo volumen
Historialningunocada versión sigue siendo legible, con Snapshot y Diff
Logs copiadosunodos: metadatos, luego contenido

Usa kolo-blobs por sí solo cuando tu app ya conoce sus archivos y solo necesita guardar, enviar y comprobar bytes, como un adjunto o una descarga. Usa kolo-files cuando la gente comparte una carpeta que cambia, necesita nombres y carpetas o quiere volver a una versión anterior.

Qué acaba de pasar

Todos los pasos

Archivos sobre blobs

kolo-files decide los nombres, las carpetas y las versiones. kolo-blobs guarda y comprueba los bytes de cada versión.

  1. Un volumen son dos logs de kolo-store de un mismo dueño: el log de metadatos, una op por cambio, y el log de contenido, que guarda objetos de kolo-blobs. La entrada 0 del log de metadatos nombra el log de contenido.
  2. WriteFile pasa los bytes del archivo a kolo-blobs bajo la clave propia del archivo. Sus fragmentos y su raíz se convierten en entradas del log de contenido, y el hash de la raíz es el ID del blob.
  3. También escribe una tabla de objetos, un segundo blob bajo la misma clave, que enumera la entrada del log de contenido de cada objeto, para que un lector los encuentre sin recorrer el log.
  4. La op CREATE guarda el nombre, la clave del archivo y la versión: el ID del blob, el ID de la tabla y dónde están los objetos de la propia tabla. kolo-log cifra cada op.
  5. Una versión nueva es una op WRITE con un blob y una tabla nuevos. La clave no cambia, así que los fragmentos sin cambios no se guardan otra vez.
  • kolo-blobs cortó cada archivo en fragmentos, cifró cada fragmento con claves derivadas de la clave del archivo y nombró el archivo por el hash de la raíz de su árbol: el ID del blob. Consulta kolo-blobs.
  • Los fragmentos y la raíz eran entradas de un log de kolo-store. kolo-sync copió ese log al receptor, comprobando cada entrada contra el head firmado del propietario. Consulta Logs y Réplicas.
  • Después el receptor comprobó cada fragmento contra el ID del blob mientras lo leía, así que un byte incorrecto habría detenido la lectura en lugar de llegar a tu disco.
  • Para la carpeta, kolo-files guardó una op por cambio en un log de metadatos y cada versión de un archivo como un blob en un log de contenido, con una clave por archivo. Una versión es la longitud del log de metadatos, así que el receptor pudo guardar cada versión y comparar dos con Diff. Consulta kolo-files.
  • La conexión era un canal de kolo-secure ligado a la clave del emisor, y el código para compartir fue lo único que se pasó a mano.

Siguientes pasos

  • Compara tus archivos con el código terminado del repositorio kolo-share-example. Sus tests ejecutan los dos programas en 127.0.0.1 y comprueban cada error que se muestra aquí.
  • Lee la página de kolo-blobs: lecturas de rangos, los formatos, los límites y cómo leer un blob desde un peer de anclaje.
  • Lee la página de kolo-files: nombres, versiones, sincronización selectiva y cómo Delete destruye un archivo.
  • Los logs de los dos programas también pueden estar en un peer de anclaje de kolo-pin, que solo guarda texto cifrado, así que un archivo sigue accesible mientras tu ordenador está apagado. Las páginas de kolo-blobs y kolo-files explican cómo un lector lee desde uno.