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í:
brew install goDescarga el instalador de Windows (el archivo .msi) desde
go.dev/dl y ejecútalo. Añade Go a tu PATH. Después
abre PowerShell.
Usa el paquete golang de tu distribución si es la versión 1.26 o
posterior. Si no, descarga el archivo .tar.gz desde
go.dev/dl y sigue los pasos para Linux de
go.dev/doc/install.
Comprueba tu versión de Go:
go versionDeberías ver la versión 1.26 o una posterior, por ejemplo:
go version go1.27.3 darwin/arm64Abre 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.
Abre PowerShell dos veces, o abre Windows Terminal y pulsa Ctrl+Shift+T para tener una segunda pestaña.
Abre tu app de terminal y pulsa Ctrl+Shift+N para tener una segunda ventana (en la mayoría de los terminales, Ctrl+Shift+T abre una pestaña).
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:
mkdir kolo-share && cd kolo-sharemkdir kolo-share; cd kolo-sharemkdir kolo-share && cd kolo-shareDespués crea un módulo de Go dentro:
go mod init example.com/kolo-shareGo responde:
go: creating new go.mod: module example.com/kolo-share3Descarga 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.
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.0Go 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:
Un archivo, dos terminales
El código para compartir es lo único que pasas a mano. Quien lo tenga puede leer el archivo.
- 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.
- 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.
- 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.
- 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.
- 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.
// 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:
sendcrea una identidad nueva para esta ejecución conkoloid.Generatey un log de kolo-store en una carpeta temporal nueva (openStore), que se borra cuando el programa se detiene.koloblobs.NewKeycrea una clave aleatoria para este archivo, yWritecorta 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, conio.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 conKeyssolo a esa identidad, así que un peer sin el código no obtiene nada. getse conecta conkolosecure.Dial, que comprueba que el otro lado tiene la clave del emisor.kolosync.FetchHeaderyOpenReplicacrean una copia local del log del emisor, ykolosync.Pullla llena, comprobando cada entrada contra el head firmado del emisor.Opencomprueba la raíz del blob contra el ID y la clave, eio.Copylee 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.gettambién se protege de un código que viene de otra persona. Se detiene conthe sender offers more than -max-bytes allows; only get codes from people you trustcuando lo que descarga (el almacén temporal) o lo que escribe supera-max-bytes, 1 GiB por defecto (por ejemplogo run ./file -max-bytes 100000000 get CODE copy.jpg). Un código que nombra0.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 enpsni en el historial del shell:echo CODE | go run ./file get - copy.txt.explainconvierte los errores de kolo-blobs en frases: una clave incorrecta (ErrWrongKey), un objeto que falla una comprobación (ErrCorrupt) o uno que falta (ErrNotFound).-listenes la dirección en la que escucha el emisor,127.0.0.1:0por 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:
echo "hello from terminal 1" > hello.txtSet-Content hello.txt "hello from terminal 1"echo "hello from terminal 1" > hello.txtSirve 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:
go run ./file send hello.txtLa 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:
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 stopUn 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):
cd kolo-shareDespués ejecuta get con el código que copiaste, entre comillas simples, y
un nombre para la copia:
go run ./file get '<share code>' copy.txtSustituye <share code> por el código entero, incluido kolo-file:. El
Terminal 2 imprime:
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 2b3bbe311b98a8d367296b62fcb806cb076ccddb893f9f02dbd0c327c98e2385Y el Terminal 1 muestra cómo llega y se va el receptor, con el nombre de su clave:
21:06:38 peer db309a79 connected
21:06:38 peer db309a79 left8Comprueba 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:
shasum -a 256 hello.txt copy.txtGet-FileHash hello.txt, copy.txtsha256sum hello.txt copy.txtLas dos líneas llevan el mismo hash:
2b3bbe311b98a8d367296b62fcb806cb076ccddb893f9f02dbd0c327c98e2385 hello.txt
2b3bbe311b98a8d367296b62fcb806cb076ccddb893f9f02dbd0c327c98e2385 copy.txtGet-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:
go run ./file get '<share code>' copy.txt21:06:39 copy.txt already exists; choose a new name
exit status 1La última línea viene de go run: el programa terminó con un error. Ahora
dale algo que no es un código:
go run ./file get 'kolo-file:abc' other.txt21:06:39 this is not a file share code; copy the whole line, it starts with "kolo-file:"
exit status 1Pulsa 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:
go run ./file get '<share code>' late.txtAl cabo de unos segundos:
21:06:53 cannot reach the sender at 127.0.0.1:62364: kolotransport: timeout
exit status 1late.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.
Una carpeta y sus versiones
El receptor guarda cada versión en una carpeta propia, así que las versiones anteriores se quedan como estaban.
- 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.
- 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.
- 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.
- 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.
- 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:
// 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:
sendcrea dos logs ykolofiles.Createhace un volumen con ellos.updaterecorre la carpeta: llama aMkdirpor cada carpeta nueva, aWriteFilepor cada archivo nuevo o cambiado y aDeletepor 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, porqueWriteFilesiempre añade una versión, aunque el contenido sea el mismo.- Cada vez que pulsas Intro,
updatese vuelve a ejecutar y el emisor imprime la versión nueva, onothing 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.
gethace pull del log de metadatos, encuentra el log de contenido conkolofiles.ContentLogy también hace pull de él, y luego abre el volumen conOpenReader. UnVolumees un sistema de archivosio/fs, así queos.CopyFSlo guarda en disco, y cada archivo que lee se comprueba contra su ID de blob. Como el primer programa, rechaza unOUTque ya existe y borra una versión que no pudo guardar entera.OUTy las carpetas que contiene se crean con modo 0700, así que solo tú puedes leerlas.getse detiene conthe sender offers more than -max-bytes allows; only get codes from people you trustcuando lo que descarga, o todas las versiones que escribió enOUTjuntas, 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),getvuelve a hacer pull de los dos logs, primero el de metadatos, y llama aRefresh. Cuando la versión ha crecido,Diffenumera 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:
mkdir -p shared/notes && echo "buy bread" > shared/todo.txt && echo "first draft" > shared/notes/ideas.txt && cp hello.txt shared/mkdir shared\notes; Set-Content shared\todo.txt "buy bread"; Set-Content shared\notes\ideas.txt "first draft"; Copy-Item hello.txt shared\mkdir -p shared/notes && echo "buy bread" > shared/todo.txt && echo "first draft" > shared/notes/ideas.txt && cp hello.txt shared/Compártela:
go run ./folder send shared21: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 stopsLa 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:
go run ./folder get '<share code>' copy21:07:02 saved version 5 in copy/v5, every file checked against its blob IDDeja 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.
echo "buy bread and milk" > shared/todo.txt && echo "plans for the weekend" > shared/plans.txt && rm shared/hello.txtSet-Content shared\todo.txt "buy bread and milk"; Set-Content shared\plans.txt "plans for the weekend"; Remove-Item shared\hello.txtecho "buy bread and milk" > shared/todo.txt && echo "plans for the weekend" > shared/plans.txt && rm shared/hello.txtDespués pulsa Intro en el Terminal 1:
21:07:06 published version 9Esta 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:
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 IDcopy/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ó:
21:07:18 lost the sender: kolosync: timeout: opening a stream
exit status 1Entre 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:
-listenvale127.0.0.1:0por defecto. - En la misma red local, el emisor pasa
-listenantes desend, 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 no0.0.0.0; si no,sendse 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
| Aspecto | file (kolo-blobs) | folder (kolo-files) |
|---|---|---|
| Qué se comparte | los bytes de un archivo | un árbol de archivos y carpetas, con sus nombres |
| Qué lleva el código | el ID del blob y la clave del archivo | el ID del log de metadatos; las claves de los archivos viajan dentro de ese log |
| Un cambio | un archivo nuevo es un blob nuevo y un código nuevo | cada cambio es una versión nueva del mismo volumen |
| Historial | ninguno | cada versión sigue siendo legible, con Snapshot y Diff |
| Logs copiados | uno | dos: 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
Archivos sobre blobs
kolo-files decide los nombres, las carpetas y las versiones. kolo-blobs guarda y comprueba los bytes de cada versión.
- 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.
- 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.
- 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.
- 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.
- 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.1y 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
Deletedestruye 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.