generate identity
This commit is contained in:
@@ -1,3 +1,5 @@
|
|||||||
*.db
|
*.db
|
||||||
*.db-wal
|
*.db-wal
|
||||||
*.db-shm
|
*.db-shm
|
||||||
|
*.key
|
||||||
|
.cluster-key-*
|
||||||
|
|||||||
@@ -0,0 +1,73 @@
|
|||||||
|
Oui, l’idée est bonne, avec une nuance importante :
|
||||||
|
- Cluster = un domaine de confiance (une racine d’identité), composé d’un ou plusieurs nœuds. Les nœuds sont les membres ; le cluster est l’ensemble.
|
||||||
|
- Fédération = relation de confiance entre plusieurs clusters (plusieurs racines distinctes), pas entre nœuds isolés.
|
||||||
|
|
||||||
|
Unité
|
||||||
|
Identité
|
||||||
|
But
|
||||||
|
Clés privées
|
||||||
|
Exemple :
|
||||||
|
- Cluster A : racine A, nœuds A1, A2.
|
||||||
|
- Cluster B : racine B, nœuds B1, B2.
|
||||||
|
- Fédération A↔B : A1 peut voir certains documents de B, selon un accord signé et des politiques. Mais A et B restent deux clusters distincts, avec leurs propres racines, ACL et gouvernance.
|
||||||
|
Donc :
|
||||||
|
- un cluster peut n’avoir qu’un seul nœud ;
|
||||||
|
- une fédération implique au moins deux clusters ;
|
||||||
|
- des nœuds de clusters différents ne deviennent pas un seul cluster : ils restent séparés et se parlent via la fédération.
|
||||||
|
Dans le schéma MediarrV2, visibility = 'FEDERATED' correspond à ce second niveau : un document partageable hors du cluster, pas simplement entre nœuds du même cluster.
|
||||||
|
|
||||||
|
|
||||||
|
# Exmple concrait
|
||||||
|
|
||||||
|
Prenons un exemple concret, type Mediarr familial.
|
||||||
|
Le décor
|
||||||
|
Cluster « Maison » (racine M) :
|
||||||
|
- nœuds : hub-maison (toujours allumé), nas-maison, portable-papa
|
||||||
|
- utilisateurs : papa, maman, enfant
|
||||||
|
- bibliothèques : Films, Photos, Vacances
|
||||||
|
Cluster « Amis » (racine A) :
|
||||||
|
- nœuds : hub-ami, portable-jean
|
||||||
|
- utilisateurs : jean, groupe-proches
|
||||||
|
- bibliothèques : Films-Amis, Photos-Amis
|
||||||
|
1. Dans un cluster : coordonner, répliquer, partager les ACL
|
||||||
|
Ce que tu peux faire
|
||||||
|
- Coordonner : papa ajoute Film.mp4 sur portable-papa. Le portable pousse la version au hub-maison, qui attribue le seq et met à jour head_version_id. Les autres nœuds du cluster voient la même arborescence.
|
||||||
|
- Répliquer : le hub-maison réplique le blob vers nas-maison. Si le NAS est éteint, il rattrape plus tard. La politique de stockage (min_remote_replicas) s’applique à l’intérieur du cluster.
|
||||||
|
- Partager les ACL : un ACL donne READ au groupe enfant sur Photos. Comme tous les nœuds partagent les mêmes principal.id et la même racine M, l’ACL est comprise et appliquée de la même façon sur hub-maison, nas-maison et portable-papa.
|
||||||
|
- Cohérence : déplacer un document, restaurer depuis la corbeille, changer une ACL, résoudre un conflit de version : tout cela reste dans le même domaine de confiance.
|
||||||
|
- Identité : papa peut se connecter sur n’importe quel nœud du cluster et retrouver ses droits.
|
||||||
|
Ce que tu ne peux pas faire
|
||||||
|
- Prendre un nœud avec une autre clé racine et le considérer comme membre du cluster. Il formerait un autre cluster.
|
||||||
|
- Utiliser une adresse IP comme identité de nœud. L’IP peut changer, le cluster s’appuie sur les clés/identités.
|
||||||
|
- Donner accès à Vacances à jean (utilisateur du cluster Amis) comme s’il était un utilisateur local. Sans fédération, jean n’existe pas dans le cluster Maison.
|
||||||
|
- Fusionner les bases ou les annuaires des deux clusters.
|
||||||
|
2. En fédération : échanger/partager entre clusters, avec politiques
|
||||||
|
La fédération commence par un accord de confiance : Maison et Amis échangent leurs clés publiques de cluster et signent un contrat de fédération.
|
||||||
|
Exemple d’accord :
|
||||||
|
- Maison partage la bibliothèque Vacances avec le cluster Amis.
|
||||||
|
- Visibilité : FEDERATED.
|
||||||
|
- Sujet distant autorisé : groupe-proches (côté Amis) → READ.
|
||||||
|
- Expiration : 31/12/2026.
|
||||||
|
- Pas d’écriture, pas d’accès aux autres bibliothèques.
|
||||||
|
- Cache/relais autorisés selon la politique.
|
||||||
|
Ce que tu peux faire
|
||||||
|
- jean (dans groupe-proches) voit Vacances depuis hub-ami, sans devenir un utilisateur local de Maison.
|
||||||
|
- Maison peut révoquer l’accès ou changer l’expiration ; Amis doit re-vérifier.
|
||||||
|
- Amis peut mettre en cache les métadonnées/contenus autorisés, selon la politique de fédération.
|
||||||
|
- Chaque cluster garde sa propre racine, ses utilisateurs, ses ACL internes et sa gouvernance.
|
||||||
|
- On peut partager une partie seulement (une bibliothèque, une collection), pas tout le cluster.
|
||||||
|
Ce que tu ne peux pas faire
|
||||||
|
- jean ne peut pas obtenir ADMIN sur Vacances sauf si Maison l’accorde explicitement.
|
||||||
|
- jean ne peut pas voir Films ou Photos si ces bibliothèques ne sont pas partagées.
|
||||||
|
- Amis ne peut pas modifier les ACL internes de Maison, ni utiliser la clé privée M.
|
||||||
|
- Amis ne peut pas forcer Maison à stocker ses blobs, ni fusionner les deux bases.
|
||||||
|
- On ne peut pas supposer qu’un utilisateur Amis est automatiquement le même que quelqu’un de Maison : il faut un mapping d’identité explicite.
|
||||||
|
- Une fédération n’est pas une fusion : les clusters restent souverains.
|
||||||
|
Et vice versa
|
||||||
|
- Amis peut partager Photos-Amis avec Maison, avec ses propres règles.
|
||||||
|
- Maison ne voit pas Films-Amis tant qu’Amis ne l’a pas partagé.
|
||||||
|
- Chaque cluster peut couper la fédération unilatéralement.
|
||||||
|
Règle simple
|
||||||
|
- Cluster = « chez moi » : je coordonne mes nœuds, je réplique mes données, j’applique mes ACL partout dans mon domaine.
|
||||||
|
- Fédération = « pont entre chez moi et chez toi » : je partage ce que je choisis, avec qui je choisis, selon des règles et une durée, sans fusionner nos identités ni nos clés.
|
||||||
|
Dans le schéma, visibility = 'FEDERATED' et les futures tables document_remote, share_link, etc. servent à matérialiser ce second niveau. Le cluster reste le domaine de confiance de base.
|
||||||
@@ -0,0 +1,192 @@
|
|||||||
|
package cluster
|
||||||
|
|
||||||
|
import (
|
||||||
|
"crypto/ed25519"
|
||||||
|
"crypto/rand"
|
||||||
|
"crypto/x509"
|
||||||
|
"encoding/pem"
|
||||||
|
"errors"
|
||||||
|
"fmt"
|
||||||
|
"os"
|
||||||
|
"path/filepath"
|
||||||
|
)
|
||||||
|
|
||||||
|
const privateKeyPEMType = "PRIVATE KEY"
|
||||||
|
|
||||||
|
// Identity est l'identité racine du cluster. La clé privée ne doit jamais
|
||||||
|
// être persistée en base ni journalisée.
|
||||||
|
type Identity struct {
|
||||||
|
PrivateKey ed25519.PrivateKey
|
||||||
|
PublicKey ed25519.PublicKey
|
||||||
|
Path string
|
||||||
|
}
|
||||||
|
|
||||||
|
// LoadOrCreate charge la clé privée PKCS#8 PEM présente dans path. Si elle
|
||||||
|
// n'existe pas et que allowCreate est vrai, une nouvelle paire Ed25519 est
|
||||||
|
// générée et écrite avec les permissions 0600.
|
||||||
|
func LoadOrCreate(path string, allowCreate bool) (Identity, error) {
|
||||||
|
if path == "" {
|
||||||
|
return Identity{}, errors.New("cluster : chemin de clé vide")
|
||||||
|
}
|
||||||
|
|
||||||
|
identity, err := load(path)
|
||||||
|
if err == nil {
|
||||||
|
return identity, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
if !errors.Is(err, os.ErrNotExist) {
|
||||||
|
return Identity{}, err
|
||||||
|
}
|
||||||
|
|
||||||
|
if !allowCreate {
|
||||||
|
return Identity{}, fmt.Errorf("cluster : clé absente (%s) et création désactivée", path)
|
||||||
|
}
|
||||||
|
|
||||||
|
return create(path)
|
||||||
|
}
|
||||||
|
|
||||||
|
func load(path string) (Identity, error) {
|
||||||
|
info, err := os.Lstat(path)
|
||||||
|
if err != nil {
|
||||||
|
return Identity{}, err
|
||||||
|
}
|
||||||
|
|
||||||
|
if info.Mode()&os.ModeSymlink != 0 {
|
||||||
|
return Identity{}, fmt.Errorf("cluster : %s est un lien symbolique, refusé", path)
|
||||||
|
}
|
||||||
|
|
||||||
|
if !info.Mode().IsRegular() {
|
||||||
|
return Identity{}, fmt.Errorf("cluster : %s n'est pas un fichier régulier", path)
|
||||||
|
}
|
||||||
|
|
||||||
|
if info.Mode().Perm()&0o077 != 0 {
|
||||||
|
return Identity{}, fmt.Errorf(
|
||||||
|
"cluster : permissions trop larges sur %s (%04o), attendu 0600",
|
||||||
|
path,
|
||||||
|
info.Mode().Perm(),
|
||||||
|
)
|
||||||
|
}
|
||||||
|
|
||||||
|
data, err := os.ReadFile(path)
|
||||||
|
if err != nil {
|
||||||
|
return Identity{}, err
|
||||||
|
}
|
||||||
|
|
||||||
|
block, _ := pem.Decode(data)
|
||||||
|
if block == nil {
|
||||||
|
return Identity{}, fmt.Errorf("cluster : %s ne contient pas de PEM valide", path)
|
||||||
|
}
|
||||||
|
|
||||||
|
if block.Type != privateKeyPEMType {
|
||||||
|
return Identity{}, fmt.Errorf("cluster : type PEM %q inattendu", block.Type)
|
||||||
|
}
|
||||||
|
|
||||||
|
parsed, err := x509.ParsePKCS8PrivateKey(block.Bytes)
|
||||||
|
if err != nil {
|
||||||
|
return Identity{}, fmt.Errorf("cluster : clé PKCS#8 invalide : %w", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
privateKey, ok := parsed.(ed25519.PrivateKey)
|
||||||
|
if !ok {
|
||||||
|
return Identity{}, fmt.Errorf("cluster : clé de type %T, attendu ed25519.PrivateKey", parsed)
|
||||||
|
}
|
||||||
|
|
||||||
|
publicKey, ok := privateKey.Public().(ed25519.PublicKey)
|
||||||
|
if !ok {
|
||||||
|
return Identity{}, errors.New("cluster : clé publique Ed25519 invalide")
|
||||||
|
}
|
||||||
|
|
||||||
|
return Identity{
|
||||||
|
PrivateKey: privateKey,
|
||||||
|
PublicKey: publicKey,
|
||||||
|
Path: path,
|
||||||
|
}, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func create(path string) (Identity, error) {
|
||||||
|
publicKey, privateKey, err := ed25519.GenerateKey(rand.Reader)
|
||||||
|
if err != nil {
|
||||||
|
return Identity{}, fmt.Errorf("cluster : génération de clé : %w", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
der, err := x509.MarshalPKCS8PrivateKey(privateKey)
|
||||||
|
if err != nil {
|
||||||
|
return Identity{}, fmt.Errorf("cluster : encodage PKCS#8 : %w", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
data := pem.EncodeToMemory(&pem.Block{Type: privateKeyPEMType, Bytes: der})
|
||||||
|
if data == nil {
|
||||||
|
return Identity{}, errors.New("cluster : encodage PEM")
|
||||||
|
}
|
||||||
|
|
||||||
|
dir := filepath.Dir(path)
|
||||||
|
if dir == "" {
|
||||||
|
dir = "."
|
||||||
|
}
|
||||||
|
if dir != "." {
|
||||||
|
if err := os.MkdirAll(dir, 0o700); err != nil {
|
||||||
|
return Identity{}, fmt.Errorf("cluster : création du répertoire %s : %w", dir, err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
temp, err := os.CreateTemp(dir, ".cluster-key-*")
|
||||||
|
if err != nil {
|
||||||
|
return Identity{}, fmt.Errorf("cluster : création du fichier temporaire : %w", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
tempPath := temp.Name()
|
||||||
|
cleanup := func() {
|
||||||
|
_ = temp.Close()
|
||||||
|
_ = os.Remove(tempPath)
|
||||||
|
}
|
||||||
|
|
||||||
|
if err := temp.Chmod(0o600); err != nil {
|
||||||
|
cleanup()
|
||||||
|
return Identity{}, fmt.Errorf("cluster : permissions du fichier temporaire : %w", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
written, writeErr := temp.Write(data)
|
||||||
|
if writeErr != nil || written != len(data) {
|
||||||
|
cleanup()
|
||||||
|
|
||||||
|
if writeErr != nil {
|
||||||
|
return Identity{}, fmt.Errorf("cluster : écriture de %s : %w", tempPath, writeErr)
|
||||||
|
}
|
||||||
|
|
||||||
|
return Identity{}, fmt.Errorf("cluster : écriture partielle de %s", tempPath)
|
||||||
|
}
|
||||||
|
|
||||||
|
if err := temp.Sync(); err != nil {
|
||||||
|
cleanup()
|
||||||
|
return Identity{}, fmt.Errorf("cluster : synchronisation de %s : %w", tempPath, err)
|
||||||
|
}
|
||||||
|
|
||||||
|
if err := temp.Close(); err != nil {
|
||||||
|
_ = os.Remove(tempPath)
|
||||||
|
return Identity{}, fmt.Errorf("cluster : fermeture de %s : %w", tempPath, err)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Link est atomique et échoue si path existe déjà : on ne peut pas écraser
|
||||||
|
// une clé créée par un autre processus.
|
||||||
|
if err := os.Link(tempPath, path); err != nil {
|
||||||
|
_ = os.Remove(tempPath)
|
||||||
|
|
||||||
|
if errors.Is(err, os.ErrExist) {
|
||||||
|
return load(path)
|
||||||
|
}
|
||||||
|
|
||||||
|
return Identity{}, fmt.Errorf("cluster : installation de %s : %w", path, err)
|
||||||
|
}
|
||||||
|
|
||||||
|
_ = os.Remove(tempPath)
|
||||||
|
|
||||||
|
return Identity{
|
||||||
|
PrivateKey: privateKey,
|
||||||
|
PublicKey: publicKey,
|
||||||
|
Path: path,
|
||||||
|
}, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
func (i Identity) PublicKeyBytes() []byte {
|
||||||
|
return append([]byte(nil), i.PublicKey...)
|
||||||
|
}
|
||||||
@@ -0,0 +1,148 @@
|
|||||||
|
package cluster
|
||||||
|
|
||||||
|
import (
|
||||||
|
"bytes"
|
||||||
|
"os"
|
||||||
|
"path/filepath"
|
||||||
|
"sync"
|
||||||
|
"testing"
|
||||||
|
)
|
||||||
|
|
||||||
|
func TestLoadOrCreateGeneratesAndReloads(t *testing.T) {
|
||||||
|
path := filepath.Join(t.TempDir(), "cluster.key")
|
||||||
|
|
||||||
|
first, err := LoadOrCreate(path, true)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("LoadOrCreate (création) : %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
info, err := os.Stat(path)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("Stat : %v", err)
|
||||||
|
}
|
||||||
|
if got := info.Mode().Perm(); got != 0o600 {
|
||||||
|
t.Fatalf("permissions = %04o, attendu 0600", got)
|
||||||
|
}
|
||||||
|
|
||||||
|
second, err := LoadOrCreate(path, true)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("LoadOrCreate (relecture) : %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
if !bytes.Equal(first.PublicKey, second.PublicKey) {
|
||||||
|
t.Fatal("clés publiques différentes après relecture")
|
||||||
|
}
|
||||||
|
if !bytes.Equal(first.PrivateKey, second.PrivateKey) {
|
||||||
|
t.Fatal("clés privées différentes après relecture")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestLoadOrCreateNoCreate(t *testing.T) {
|
||||||
|
path := filepath.Join(t.TempDir(), "missing.key")
|
||||||
|
|
||||||
|
if _, err := LoadOrCreate(path, false); err == nil {
|
||||||
|
t.Fatal("LoadOrCreate aurait dû échouer sans création autorisée")
|
||||||
|
}
|
||||||
|
|
||||||
|
if _, err := os.Stat(path); !os.IsNotExist(err) {
|
||||||
|
t.Fatalf("le fichier ne devrait pas exister : %v", err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestLoadOrCreateCorrupt(t *testing.T) {
|
||||||
|
path := filepath.Join(t.TempDir(), "cluster.key")
|
||||||
|
if err := os.WriteFile(path, []byte("pas une clé"), 0o600); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
|
||||||
|
if _, err := LoadOrCreate(path, true); err == nil {
|
||||||
|
t.Fatal("LoadOrCreate aurait dû refuser un fichier corrompu")
|
||||||
|
}
|
||||||
|
|
||||||
|
data, err := os.ReadFile(path)
|
||||||
|
if err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
if string(data) != "pas une clé" {
|
||||||
|
t.Fatal("le fichier corrompu a été modifié")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestLoadOrCreateRejectsLoosePermissions(t *testing.T) {
|
||||||
|
path := filepath.Join(t.TempDir(), "cluster.key")
|
||||||
|
|
||||||
|
if _, err := LoadOrCreate(path, true); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
if err := os.Chmod(path, 0o644); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
|
||||||
|
if _, err := LoadOrCreate(path, true); err == nil {
|
||||||
|
t.Fatal("LoadOrCreate aurait dû refuser des permissions 0644")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestLoadOrCreateRejectsSymlink(t *testing.T) {
|
||||||
|
dir := t.TempDir()
|
||||||
|
target := filepath.Join(dir, "target.key")
|
||||||
|
link := filepath.Join(dir, "cluster.key")
|
||||||
|
|
||||||
|
if _, err := LoadOrCreate(target, true); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
if err := os.Symlink(target, link); err != nil {
|
||||||
|
t.Skipf("symlink non supporté : %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
if _, err := LoadOrCreate(link, true); err == nil {
|
||||||
|
t.Fatal("LoadOrCreate aurait dû refuser un lien symbolique")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestLoadOrCreateConcurrent(t *testing.T) {
|
||||||
|
path := filepath.Join(t.TempDir(), "cluster.key")
|
||||||
|
|
||||||
|
const goroutines = 16
|
||||||
|
|
||||||
|
type result struct {
|
||||||
|
identity Identity
|
||||||
|
err error
|
||||||
|
}
|
||||||
|
|
||||||
|
results := make(chan result, goroutines)
|
||||||
|
var waitGroup sync.WaitGroup
|
||||||
|
|
||||||
|
for range goroutines {
|
||||||
|
waitGroup.Add(1)
|
||||||
|
|
||||||
|
go func() {
|
||||||
|
defer waitGroup.Done()
|
||||||
|
|
||||||
|
identity, err := LoadOrCreate(path, true)
|
||||||
|
results <- result{identity: identity, err: err}
|
||||||
|
}()
|
||||||
|
}
|
||||||
|
|
||||||
|
waitGroup.Wait()
|
||||||
|
close(results)
|
||||||
|
|
||||||
|
var expected []byte
|
||||||
|
|
||||||
|
for current := range results {
|
||||||
|
if current.err != nil {
|
||||||
|
t.Fatalf("LoadOrCreate concurrent : %v", current.err)
|
||||||
|
}
|
||||||
|
|
||||||
|
publicKey := current.identity.PublicKeyBytes()
|
||||||
|
|
||||||
|
if expected == nil {
|
||||||
|
expected = publicKey
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
if !bytes.Equal(expected, publicKey) {
|
||||||
|
t.Fatal("deux processus concurrents ont obtenu des clés différentes")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
@@ -282,6 +282,29 @@ func (q *Queries) GetAccountByLoginKey(ctx context.Context, loginKey string) (Ac
|
|||||||
return i, err
|
return i, err
|
||||||
}
|
}
|
||||||
|
|
||||||
|
const getClusterPrincipal = `-- name: GetClusterPrincipal :one
|
||||||
|
SELECT id, kind, name, public_key, status, successor_id, created_at, disabled_at
|
||||||
|
FROM principal
|
||||||
|
WHERE kind = 'cluster'
|
||||||
|
LIMIT 1
|
||||||
|
`
|
||||||
|
|
||||||
|
func (q *Queries) GetClusterPrincipal(ctx context.Context) (Principal, error) {
|
||||||
|
row := q.db.QueryRowContext(ctx, getClusterPrincipal)
|
||||||
|
var i Principal
|
||||||
|
err := row.Scan(
|
||||||
|
&i.ID,
|
||||||
|
&i.Kind,
|
||||||
|
&i.Name,
|
||||||
|
&i.PublicKey,
|
||||||
|
&i.Status,
|
||||||
|
&i.SuccessorID,
|
||||||
|
&i.CreatedAt,
|
||||||
|
&i.DisabledAt,
|
||||||
|
)
|
||||||
|
return i, err
|
||||||
|
}
|
||||||
|
|
||||||
const getMembership = `-- name: GetMembership :one
|
const getMembership = `-- name: GetMembership :one
|
||||||
SELECT group_id, member_id, role, created_at
|
SELECT group_id, member_id, role, created_at
|
||||||
FROM membership
|
FROM membership
|
||||||
|
|||||||
@@ -40,6 +40,12 @@ FROM principal
|
|||||||
WHERE kind = sqlc.arg(kind)
|
WHERE kind = sqlc.arg(kind)
|
||||||
AND name = sqlc.arg(name);
|
AND name = sqlc.arg(name);
|
||||||
|
|
||||||
|
-- name: GetClusterPrincipal :one
|
||||||
|
SELECT *
|
||||||
|
FROM principal
|
||||||
|
WHERE kind = 'cluster'
|
||||||
|
LIMIT 1;
|
||||||
|
|
||||||
-- name: ListPrincipals :many
|
-- name: ListPrincipals :many
|
||||||
SELECT *
|
SELECT *
|
||||||
FROM principal
|
FROM principal
|
||||||
|
|||||||
+20
-1
@@ -1,32 +1,51 @@
|
|||||||
package node
|
package node
|
||||||
|
|
||||||
import (
|
import (
|
||||||
|
"mediarr/cluster"
|
||||||
"mediarr/database"
|
"mediarr/database"
|
||||||
)
|
)
|
||||||
|
|
||||||
type Node struct {
|
type Node struct {
|
||||||
db database.DatabaseClient
|
db database.DatabaseClient
|
||||||
|
clusterKeyPath string
|
||||||
|
cluster cluster.Identity
|
||||||
}
|
}
|
||||||
|
|
||||||
type NewNodeParams struct {
|
type NewNodeParams struct {
|
||||||
DatabaseName string
|
DatabaseName string
|
||||||
|
ClusterKeyPath string
|
||||||
}
|
}
|
||||||
|
|
||||||
func NewNode(params NewNodeParams) (error, Node) {
|
func NewNode(params NewNodeParams) (error, Node) {
|
||||||
|
|
||||||
|
var databaseName *string
|
||||||
|
if params.DatabaseName != "" {
|
||||||
|
databaseName = ¶ms.DatabaseName
|
||||||
|
}
|
||||||
|
|
||||||
err, db := database.NewDatabase(database.NewDatabaseParams{
|
err, db := database.NewDatabase(database.NewDatabaseParams{
|
||||||
DatabaseName: ¶ms.DatabaseName,
|
DatabaseName: databaseName,
|
||||||
})
|
})
|
||||||
|
|
||||||
if err != nil {
|
if err != nil {
|
||||||
return err, Node{}
|
return err, Node{}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
clusterKeyPath := params.ClusterKeyPath
|
||||||
|
if clusterKeyPath == "" {
|
||||||
|
clusterKeyPath = "cluster.key"
|
||||||
|
}
|
||||||
|
|
||||||
return nil, Node{
|
return nil, Node{
|
||||||
db: *db,
|
db: *db,
|
||||||
|
clusterKeyPath: clusterKeyPath,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
func (n *Node) Close() error {
|
func (n *Node) Close() error {
|
||||||
return n.db.Close()
|
return n.db.Close()
|
||||||
}
|
}
|
||||||
|
|
||||||
|
func (n *Node) ClusterIdentity() cluster.Identity {
|
||||||
|
return n.cluster
|
||||||
|
}
|
||||||
|
|||||||
@@ -1,9 +1,12 @@
|
|||||||
package node
|
package node
|
||||||
|
|
||||||
import (
|
import (
|
||||||
|
"bytes"
|
||||||
"context"
|
"context"
|
||||||
"database/sql"
|
"database/sql"
|
||||||
"errors"
|
"errors"
|
||||||
|
"fmt"
|
||||||
|
"mediarr/cluster"
|
||||||
"mediarr/database"
|
"mediarr/database"
|
||||||
"mediarr/ident"
|
"mediarr/ident"
|
||||||
"time"
|
"time"
|
||||||
@@ -29,8 +32,64 @@ func (n *Node) Up() error {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
return n.ensureClusterIdentity(ctx)
|
||||||
|
|
||||||
|
}
|
||||||
|
|
||||||
|
func (n *Node) ensureClusterIdentity(ctx context.Context) error {
|
||||||
|
|
||||||
|
principal, err := n.db.Queries.GetClusterPrincipal(ctx)
|
||||||
|
|
||||||
|
switch {
|
||||||
|
case err == nil:
|
||||||
|
identity, loadErr := cluster.LoadOrCreate(n.clusterKeyPath, false)
|
||||||
|
if loadErr != nil {
|
||||||
|
return fmt.Errorf("cluster : principal présent en base mais clé indisponible : %w", loadErr)
|
||||||
|
}
|
||||||
|
|
||||||
|
if !bytes.Equal(principal.PublicKey, identity.PublicKey) {
|
||||||
|
return errors.New("cluster : la clé publique de cluster.key ne correspond pas au principal en base")
|
||||||
|
}
|
||||||
|
|
||||||
|
n.cluster = identity
|
||||||
return nil
|
return nil
|
||||||
|
|
||||||
|
case errors.Is(err, sql.ErrNoRows):
|
||||||
|
identity, createErr := cluster.LoadOrCreate(n.clusterKeyPath, true)
|
||||||
|
if createErr != nil {
|
||||||
|
return createErr
|
||||||
|
}
|
||||||
|
|
||||||
|
clusterID, idErr := ident.NewV7()
|
||||||
|
if idErr != nil {
|
||||||
|
return idErr
|
||||||
|
}
|
||||||
|
|
||||||
|
_, createErr = n.db.WriteQueries.CreatePrincipal(ctx, database.CreatePrincipalParams{
|
||||||
|
ID: clusterID,
|
||||||
|
Kind: "cluster",
|
||||||
|
Name: "cluster",
|
||||||
|
PublicKey: identity.PublicKeyBytes(),
|
||||||
|
Status: "active",
|
||||||
|
CreatedAt: time.Now().UnixMilli(),
|
||||||
|
})
|
||||||
|
if createErr != nil {
|
||||||
|
existing, getErr := n.db.Queries.GetClusterPrincipal(ctx)
|
||||||
|
if getErr == nil && bytes.Equal(existing.PublicKey, identity.PublicKey) {
|
||||||
|
n.cluster = identity
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
return fmt.Errorf("cluster : création du principal : %w", createErr)
|
||||||
|
}
|
||||||
|
|
||||||
|
n.cluster = identity
|
||||||
|
return nil
|
||||||
|
|
||||||
|
default:
|
||||||
|
return fmt.Errorf("cluster : lecture du principal : %w", err)
|
||||||
|
}
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
func requiredNodePrincipals(now int64) []database.CreatePrincipalParams {
|
func requiredNodePrincipals(now int64) []database.CreatePrincipalParams {
|
||||||
|
|||||||
@@ -0,0 +1,162 @@
|
|||||||
|
package node
|
||||||
|
|
||||||
|
import (
|
||||||
|
"bytes"
|
||||||
|
"context"
|
||||||
|
"os"
|
||||||
|
"path/filepath"
|
||||||
|
"testing"
|
||||||
|
|
||||||
|
"mediarr/cluster"
|
||||||
|
)
|
||||||
|
|
||||||
|
func TestUpCreatesAndKeepsClusterIdentity(t *testing.T) {
|
||||||
|
t.Chdir(t.TempDir())
|
||||||
|
|
||||||
|
keyPath := filepath.Join(t.TempDir(), "cluster.key")
|
||||||
|
|
||||||
|
err, node := NewNode(NewNodeParams{DatabaseName: "identity", ClusterKeyPath: keyPath})
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("NewNode : %v", err)
|
||||||
|
}
|
||||||
|
t.Cleanup(func() { _ = node.Close() })
|
||||||
|
|
||||||
|
if err := node.Up(); err != nil {
|
||||||
|
t.Fatalf("Up : %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
identity := node.ClusterIdentity()
|
||||||
|
if len(identity.PublicKey) != 32 {
|
||||||
|
t.Fatalf("clé publique de %d octets, attendu 32", len(identity.PublicKey))
|
||||||
|
}
|
||||||
|
|
||||||
|
principal, err := node.db.Queries.GetClusterPrincipal(context.Background())
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("GetClusterPrincipal : %v", err)
|
||||||
|
}
|
||||||
|
if principal.Kind != "cluster" {
|
||||||
|
t.Fatalf("kind = %q, attendu cluster", principal.Kind)
|
||||||
|
}
|
||||||
|
if principal.Name != "cluster" {
|
||||||
|
t.Fatalf("name = %q, attendu cluster", principal.Name)
|
||||||
|
}
|
||||||
|
if principal.Status != "active" {
|
||||||
|
t.Fatalf("status = %q, attendu active", principal.Status)
|
||||||
|
}
|
||||||
|
if !bytes.Equal(principal.PublicKey, identity.PublicKey) {
|
||||||
|
t.Fatal("la clé publique en base ne correspond pas à la clé chargée")
|
||||||
|
}
|
||||||
|
|
||||||
|
if err := node.Up(); err != nil {
|
||||||
|
t.Fatalf("second Up : %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
again, err := node.db.Queries.GetClusterPrincipal(context.Background())
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("GetClusterPrincipal après second Up : %v", err)
|
||||||
|
}
|
||||||
|
if again.ID != principal.ID {
|
||||||
|
t.Fatal("le principal cluster a été recréé au lieu d'être réutilisé")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestUpReusesKeyWhenDatabaseRecreated(t *testing.T) {
|
||||||
|
t.Chdir(t.TempDir())
|
||||||
|
|
||||||
|
keyPath := filepath.Join(t.TempDir(), "cluster.key")
|
||||||
|
|
||||||
|
err, first := NewNode(NewNodeParams{DatabaseName: "recreate", ClusterKeyPath: keyPath})
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("NewNode : %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
if err := first.Up(); err != nil {
|
||||||
|
t.Fatalf("Up : %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
firstPublicKey := first.ClusterIdentity().PublicKeyBytes()
|
||||||
|
|
||||||
|
if err := first.Close(); err != nil {
|
||||||
|
t.Fatalf("Close : %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
removeDatabaseFiles(t, "recreate")
|
||||||
|
|
||||||
|
err, second := NewNode(NewNodeParams{DatabaseName: "recreate", ClusterKeyPath: keyPath})
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("NewNode après recréation : %v", err)
|
||||||
|
}
|
||||||
|
t.Cleanup(func() { _ = second.Close() })
|
||||||
|
|
||||||
|
if err := second.Up(); err != nil {
|
||||||
|
t.Fatalf("Up après recréation : %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
if !bytes.Equal(second.ClusterIdentity().PublicKeyBytes(), firstPublicKey) {
|
||||||
|
t.Fatal("la clé du cluster a changé après recréation de la base")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestUpFailsWhenKeyMissing(t *testing.T) {
|
||||||
|
t.Chdir(t.TempDir())
|
||||||
|
|
||||||
|
keyPath := filepath.Join(t.TempDir(), "cluster.key")
|
||||||
|
|
||||||
|
err, node := NewNode(NewNodeParams{DatabaseName: "missingkey", ClusterKeyPath: keyPath})
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("NewNode : %v", err)
|
||||||
|
}
|
||||||
|
t.Cleanup(func() { _ = node.Close() })
|
||||||
|
|
||||||
|
if err := node.Up(); err != nil {
|
||||||
|
t.Fatalf("Up : %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
if err := os.Remove(keyPath); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
|
||||||
|
if err := node.Up(); err == nil {
|
||||||
|
t.Fatal("Up aurait dû échouer sans la clé du cluster")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func TestUpFailsOnKeyMismatch(t *testing.T) {
|
||||||
|
t.Chdir(t.TempDir())
|
||||||
|
|
||||||
|
keyPath := filepath.Join(t.TempDir(), "cluster.key")
|
||||||
|
|
||||||
|
err, node := NewNode(NewNodeParams{DatabaseName: "mismatch", ClusterKeyPath: keyPath})
|
||||||
|
if err != nil {
|
||||||
|
t.Fatalf("NewNode : %v", err)
|
||||||
|
}
|
||||||
|
t.Cleanup(func() { _ = node.Close() })
|
||||||
|
|
||||||
|
if err := node.Up(); err != nil {
|
||||||
|
t.Fatalf("Up : %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
if err := os.Remove(keyPath); err != nil {
|
||||||
|
t.Fatal(err)
|
||||||
|
}
|
||||||
|
|
||||||
|
if _, err := cluster.LoadOrCreate(keyPath, true); err != nil {
|
||||||
|
t.Fatalf("génération d'une nouvelle clé : %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
if err := node.Up(); err == nil {
|
||||||
|
t.Fatal("Up aurait dû détecter un mismatch entre la clé et le principal")
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
func removeDatabaseFiles(t *testing.T, databaseName string) {
|
||||||
|
t.Helper()
|
||||||
|
|
||||||
|
for _, suffix := range []string{"", "-wal", "-shm"} {
|
||||||
|
path := databaseName + ".db" + suffix
|
||||||
|
|
||||||
|
if err := os.Remove(path); err != nil && !os.IsNotExist(err) {
|
||||||
|
t.Fatalf("suppression de %s : %v", path, err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
Reference in New Issue
Block a user