create content version

This commit is contained in:
venture
2026-11-15 10:01:30 +01:00
parent 29a6ab40f0
commit 610192e2d5
13 changed files with 2226 additions and 3 deletions
+33
View File
@@ -1,26 +1,56 @@
package node
import (
"path/filepath"
"mediarr/acl"
"mediarr/auth"
"mediarr/cluster"
"mediarr/database"
"mediarr/ident"
"mediarr/identity"
"mediarr/storage"
)
const defaultStorageBackendID = "00000000-0000-7000-8000-000000000201"
type Node struct {
db database.DatabaseClient
clusterKeyPath string
cluster cluster.Identity
storagePath string
store storage.Store
backendID ident.UUID
}
type NewNodeParams struct {
DatabaseName string
ClusterKeyPath string
StoragePath string
}
func NewNode(params NewNodeParams) (error, Node) {
storagePath := params.StoragePath
if storagePath == "" {
storagePath = "data"
}
absoluteStoragePath, err := filepath.Abs(storagePath)
if err != nil {
return err, Node{}
}
store, err := storage.NewLocal(absoluteStoragePath)
if err != nil {
return err, Node{}
}
backendID, err := ident.Parse(defaultStorageBackendID)
if err != nil {
return err, Node{}
}
var databaseName *string
if params.DatabaseName != "" {
databaseName = &params.DatabaseName
@@ -42,6 +72,9 @@ func NewNode(params NewNodeParams) (error, Node) {
return nil, Node{
db: *db,
clusterKeyPath: clusterKeyPath,
storagePath: absoluteStoragePath,
store: store,
backendID: backendID,
}
}
+7
View File
@@ -0,0 +1,7 @@
package node
import "mediarr/content"
func (n *Node) Content() *content.Service {
return content.NewService(n.db, n.store, n.backendID, n.ACL())
}
+177
View File
@@ -0,0 +1,177 @@
package node
import (
"bytes"
"context"
"crypto/sha256"
"encoding/hex"
"errors"
"io"
"strings"
"testing"
"time"
"mediarr/content"
"mediarr/database"
"mediarr/document"
"mediarr/ident"
"mediarr/identity"
)
func TestNodeContent(t *testing.T) {
t.Chdir(t.TempDir())
err, node := NewNode(NewNodeParams{DatabaseName: "content", StoragePath: "store"})
if err != nil {
t.Fatalf("NewNode : %v", err)
}
t.Cleanup(func() {
if err := node.Close(); err != nil {
t.Errorf("Close : %v", err)
}
})
if err := node.Up(); err != nil {
t.Fatalf("Up : %v", err)
}
ctx := context.Background()
owner, err := node.Identity().CreatePrincipal(ctx, identity.CreatePrincipalParams{
Kind: identity.KindUser,
Name: "owner",
})
if err != nil {
t.Fatalf("CreatePrincipal(owner) : %v", err)
}
other, err := node.Identity().CreatePrincipal(ctx, identity.CreatePrincipalParams{
Kind: identity.KindUser,
Name: "other",
})
if err != nil {
t.Fatalf("CreatePrincipal(other) : %v", err)
}
library, err := node.Documents().CreateLibrary(ctx, owner.ID, document.CreateLibraryParams{
OwnerID: owner.ID,
CreatedBy: owner.ID,
Name: "Films",
PolicyID: ident.MustParse("00000000-0000-7000-8000-000000000101"),
})
if err != nil {
t.Fatalf("CreateLibrary : %v", err)
}
videoID := createNodeContentDocument(t, &node, owner, library, "video", "film.mkv")
payload := []byte("contenu de test mediarr")
version, err := node.Content().CreateVersion(ctx, owner.ID, videoID, content.CreateVersionParams{
Source: bytes.NewReader(payload),
Mime: "video/x-matroska",
Message: "première version",
})
if err != nil {
t.Fatalf("CreateVersion : %v", err)
}
expectedRoot := sha256.Sum256(payload)
if version.Seq != 1 {
t.Fatalf("seq = %d, attendu 1", version.Seq)
}
if version.Size != int64(len(payload)) {
t.Fatalf("size = %d, attendu %d", version.Size, len(payload))
}
if !bytes.Equal(version.ContentRoot, expectedRoot[:]) {
t.Fatalf("content_root = %x, attendu %x", version.ContentRoot, expectedRoot)
}
documentRow, err := node.Documents().Get(ctx, owner.ID, videoID)
if err != nil {
t.Fatalf("Get(video) : %v", err)
}
if documentRow.HeadVersionID == nil || *documentRow.HeadVersionID != version.ID {
t.Fatalf("head_version_id = %v, attendu %s", documentRow.HeadVersionID, version.ID)
}
reader, opened, err := node.Content().OpenVersion(ctx, owner.ID, version.ID)
if err != nil {
t.Fatalf("OpenVersion : %v", err)
}
data, err := io.ReadAll(reader)
if err != nil {
_ = reader.Close()
t.Fatalf("ReadAll : %v", err)
}
if err := reader.Close(); err != nil {
t.Fatalf("Close(reader) : %v", err)
}
if !bytes.Equal(data, payload) {
t.Fatalf("contenu = %q, attendu %q", data, payload)
}
if opened.ID != version.ID {
t.Fatalf("version ouverte = %s, attendu %s", opened.ID, version.ID)
}
second, err := node.Content().CreateVersion(ctx, owner.ID, videoID, content.CreateVersionParams{
Source: bytes.NewReader(payload),
Mime: "video/x-matroska",
})
if err != nil {
t.Fatalf("CreateVersion(doublon) : %v", err)
}
if second.Seq != 2 {
t.Fatalf("seq = %d, attendu 2", second.Seq)
}
if !bytes.Equal(second.ContentRoot, version.ContentRoot) {
t.Fatalf("doublon : content_root = %x, attendu %x", second.ContentRoot, version.ContentRoot)
}
versions, err := node.Content().ListVersions(ctx, owner.ID, videoID)
if err != nil {
t.Fatalf("ListVersions : %v", err)
}
if len(versions) != 2 {
t.Fatalf("versions = %d, attendu 2", len(versions))
}
if versions[0].ID != second.ID || versions[1].ID != version.ID {
t.Fatalf("ordre des versions = %s, %s", versions[0].ID, versions[1].ID)
}
if _, _, err := node.Content().OpenVersion(ctx, other.ID, version.ID); !errors.Is(err, document.ErrPermissionDenied) {
t.Fatalf("OpenVersion sans Read : erreur = %v, attendu ErrPermissionDenied", err)
}
if _, err := node.Content().CreateVersion(ctx, owner.ID, videoID, content.CreateVersionParams{}); !errors.Is(err, content.ErrInvalidSource) {
t.Fatalf("CreateVersion sans source : erreur = %v, attendu ErrInvalidSource", err)
}
}
func createNodeContentDocument(t *testing.T, node *Node, owner *identity.Principal, parent *document.Document, kind, name string) ident.UUID {
t.Helper()
id, err := ident.NewV7()
if err != nil {
t.Fatalf("NewV7 : %v", err)
}
now := time.Now().UnixMilli()
if _, err := node.db.WriteQueries.CreateDocument(context.Background(), database.CreateDocumentParams{
ID: id,
Kind: kind,
OwnerID: owner.ID,
CreatedBy: owner.ID,
ParentID: &parent.ID,
Name: name,
NameKey: strings.ToLower(name),
Path: parent.Path + hex.EncodeToString(id[:]) + "/",
Depth: parent.Depth + 1,
Metadata: "{}",
AclInherit: 1,
Rev: 1,
CreatedAt: now,
UpdatedAt: now,
}); err != nil {
t.Fatalf("CreateDocument(%q) : %v", name, err)
}
return id
}
+34
View File
@@ -4,6 +4,7 @@ import (
"bytes"
"context"
"database/sql"
"encoding/json"
"errors"
"fmt"
"mediarr/cluster"
@@ -33,10 +34,43 @@ func (n *Node) Up() error {
}
}
if err := n.ensureStorageBackend(ctx); err != nil {
return err
}
return n.ensureClusterIdentity(ctx)
}
func (n *Node) ensureStorageBackend(ctx context.Context) error {
_, err := n.db.Queries.GetStorageBackend(ctx, n.backendID)
switch {
case err == nil:
return nil
case !errors.Is(err, sql.ErrNoRows):
return fmt.Errorf("stockage : lecture du backend : %w", err)
}
config, err := json.Marshal(map[string]string{"root": n.storagePath})
if err != nil {
return err
}
if err := n.db.WriteQueries.CreateStorageBackend(ctx, database.CreateStorageBackendParams{
ID: n.backendID,
Kind: "hub_fs",
Name: "local",
Config: string(config),
Enabled: 1,
State: "ok",
CreatedAt: time.Now().UnixMilli(),
}); err != nil {
return fmt.Errorf("stockage : création du backend : %w", err)
}
return nil
}
func (n *Node) ensureClusterIdentity(ctx context.Context) error {
principal, err := n.db.Queries.GetClusterPrincipal(ctx)