api + cli

This commit is contained in:
venture
2026-11-16 13:12:36 +01:00
parent 4f18d94158
commit 8d48fadd01
7 changed files with 1909 additions and 7 deletions
+409 -7
View File
@@ -1,22 +1,424 @@
package main
import (
"log"
"context"
"encoding/json"
"errors"
"flag"
"fmt"
"net/http"
"os"
"os/signal"
"strings"
"syscall"
"time"
"mediarr/api"
"mediarr/auth"
"mediarr/document"
"mediarr/ident"
"mediarr/identity"
"mediarr/ingest"
"mediarr/node"
)
func main() {
const defaultStoragePolicyID = "00000000-0000-7000-8000-000000000101"
err, nodeA := node.NewNode(node.NewNodeParams{DatabaseName: "database"})
func main() {
if len(os.Args) < 2 {
usage()
os.Exit(2)
}
var err error
switch os.Args[1] {
case "serve":
err = runServe(os.Args[2:])
case "user":
err = runUser(os.Args[2:])
case "library":
err = runLibrary(os.Args[2:])
case "scan":
err = runScan(os.Args[2:])
case "import":
err = runImport(os.Args[2:])
case "help", "-h", "--help":
usage()
default:
usage()
err = fmt.Errorf("commande inconnue: %s", os.Args[1])
}
if err != nil {
log.Fatalln(err)
fmt.Fprintln(os.Stderr, err)
os.Exit(1)
}
}
defer nodeA.Close()
func usage() {
fmt.Fprintln(os.Stderr, `Usage:
server serve [options]
server user create -login LOGIN -password PASSWORD [-role member|admin]
server user password -id UUID -password PASSWORD
server library create -owner UUID -name NAME [options]
server scan -actor UUID -parent UUID -path PATH [-prune]
server import -actor UUID -parent UUID -path PATH [-prune]
if err := nodeA.Up(); err != nil {
log.Fatalln(err)
Options de stockage:
-db NOM nom de la base SQLite (défaut: database)
-storage PATH répertoire de stockage (défaut: data)
-cluster-key PATH chemin de la clé cluster (défaut: cluster.key)`)
}
type nodeFlags struct {
database string
storage string
clusterKey string
}
func addNodeFlags(fs *flag.FlagSet) *nodeFlags {
flags := &nodeFlags{}
fs.StringVar(&flags.database, "db", "database", "nom de la base SQLite")
fs.StringVar(&flags.storage, "storage", "data", "répertoire de stockage")
fs.StringVar(&flags.clusterKey, "cluster-key", "cluster.key", "chemin de la clé cluster")
return flags
}
func (f *nodeFlags) open() (node.Node, error) {
err, n := node.NewNode(node.NewNodeParams{
DatabaseName: f.database,
StoragePath: f.storage,
ClusterKeyPath: f.clusterKey,
})
if err != nil {
return node.Node{}, err
}
if err := n.Up(); err != nil {
_ = n.Close()
return node.Node{}, err
}
return n, nil
}
func runServe(args []string) error {
fs := flag.NewFlagSet("serve", flag.ExitOnError)
addr := fs.String("addr", ":8080", "adresse HTTP")
flags := addNodeFlags(fs)
if err := fs.Parse(args); err != nil {
return err
}
n, err := flags.open()
if err != nil {
return err
}
defer n.Close()
server := &http.Server{
Addr: *addr,
Handler: api.NewServer(&n).Handler(),
ReadHeaderTimeout: 10 * time.Second,
IdleTimeout: 120 * time.Second,
}
ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
defer stop()
go func() {
<-ctx.Done()
shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()
_ = server.Shutdown(shutdownCtx)
}()
fmt.Printf("Mediarr écoute sur %s\n", *addr)
if err := server.ListenAndServe(); err != nil && !errors.Is(err, http.ErrServerClosed) {
return err
}
return nil
}
func runUser(args []string) error {
if len(args) == 0 {
return errors.New("usage: server user create|password [options]")
}
switch args[0] {
case "create":
return runUserCreate(args[1:])
case "password":
return runUserPassword(args[1:])
default:
return fmt.Errorf("sous-commande user inconnue: %s", args[0])
}
}
func runUserCreate(args []string) error {
fs := flag.NewFlagSet("user create", flag.ExitOnError)
login := fs.String("login", "", "login")
password := fs.String("password", "", "mot de passe (ou MEDIARR_PASSWORD)")
role := fs.String("role", identity.RoleMember, "rôle: member ou admin")
flags := addNodeFlags(fs)
if err := fs.Parse(args); err != nil {
return err
}
if *login == "" {
return errors.New("login requis")
}
passwordValue := *password
if passwordValue == "" {
passwordValue = os.Getenv("MEDIARR_PASSWORD")
}
if passwordValue == "" {
return errors.New("mot de passe requis (-password ou MEDIARR_PASSWORD)")
}
n, err := flags.open()
if err != nil {
return err
}
defer n.Close()
created, err := n.Auth().CreateUser(context.Background(), auth.CreateUserParams{
Login: *login,
Password: passwordValue,
Role: *role,
})
if err != nil {
return err
}
return printJSON(map[string]any{
"id": created.Principal.ID.String(),
"login": created.Account.Login,
"role": *role,
})
}
func runUserPassword(args []string) error {
fs := flag.NewFlagSet("user password", flag.ExitOnError)
id := fs.String("id", "", "UUID du principal")
password := fs.String("password", "", "mot de passe (ou MEDIARR_PASSWORD)")
flags := addNodeFlags(fs)
if err := fs.Parse(args); err != nil {
return err
}
principalID, err := parseID(*id, "id")
if err != nil {
return err
}
passwordValue := *password
if passwordValue == "" {
passwordValue = os.Getenv("MEDIARR_PASSWORD")
}
if passwordValue == "" {
return errors.New("mot de passe requis (-password ou MEDIARR_PASSWORD)")
}
n, err := flags.open()
if err != nil {
return err
}
defer n.Close()
if err := n.Auth().SetPassword(context.Background(), principalID, passwordValue); err != nil {
return err
}
return printJSON(map[string]string{"status": "updated", "id": principalID.String()})
}
func runLibrary(args []string) error {
if len(args) == 0 || args[0] != "create" {
return errors.New("usage: server library create -owner UUID -name NAME [options]")
}
return runLibraryCreate(args[1:])
}
func runLibraryCreate(args []string) error {
fs := flag.NewFlagSet("library create", flag.ExitOnError)
owner := fs.String("owner", "", "UUID du propriétaire")
name := fs.String("name", "", "nom de la bibliothèque")
policy := fs.String("policy", defaultStoragePolicyID, "UUID de la politique de stockage")
visibility := fs.String("visibility", document.VisibilityPrivate, "PRIVATE, CLUSTER, FEDERATED ou PUBLIC")
aclInherit := fs.Bool("acl-inherit", true, "héritage ACL")
metadata := fs.String("metadata", "{}", "métadonnées JSON")
flags := addNodeFlags(fs)
if err := fs.Parse(args); err != nil {
return err
}
ownerID, err := parseID(*owner, "owner")
if err != nil {
return err
}
policyID, err := parseID(*policy, "policy")
if err != nil {
return err
}
if *name == "" {
return errors.New("name requis")
}
if !json.Valid([]byte(*metadata)) {
return errors.New("metadata doit être un JSON valide")
}
n, err := flags.open()
if err != nil {
return err
}
defer n.Close()
created, err := n.Documents().CreateLibrary(context.Background(), ownerID, document.CreateLibraryParams{
OwnerID: ownerID,
CreatedBy: ownerID,
Name: *name,
PolicyID: policyID,
Visibility: *visibility,
ACLInherit: aclInherit,
Metadata: *metadata,
})
if err != nil {
return err
}
return printJSON(map[string]any{
"id": created.ID.String(),
"kind": created.Kind,
"name": created.Name,
"path": created.Path,
"owner_id": created.OwnerID.String(),
"policy_id": created.PolicyID.String(),
"visibility": created.Visibility,
})
}
func runScan(args []string) error {
fs := flag.NewFlagSet("scan", flag.ExitOnError)
actor := fs.String("actor", "", "UUID du principal")
parent := fs.String("parent", "", "UUID du document parent")
root := fs.String("path", "", "chemin à scanner")
prune := fs.Bool("prune", false, "supprimer les documents absents du disque")
flags := addNodeFlags(fs)
if err := fs.Parse(args); err != nil {
return err
}
actorID, err := parseID(*actor, "actor")
if err != nil {
return err
}
parentID, err := parseID(*parent, "parent")
if err != nil {
return err
}
if strings.TrimSpace(*root) == "" {
return errors.New("path requis")
}
n, err := flags.open()
if err != nil {
return err
}
defer n.Close()
result, err := n.Ingest().ScanWithOptions(context.Background(), actorID, parentID, *root, ingest.ScanOptions{Prune: *prune})
if err != nil {
return err
}
if err := printJSON(scanOutputFrom(result)); err != nil {
return err
}
if result.HasErrors() {
return fmt.Errorf("scan terminé avec %d erreur(s)", len(result.Errors))
}
return nil
}
func runImport(args []string) error {
fs := flag.NewFlagSet("import", flag.ExitOnError)
actor := fs.String("actor", "", "UUID du principal")
parent := fs.String("parent", "", "UUID du document parent")
root := fs.String("path", "", "fichier ou dossier à importer")
prune := fs.Bool("prune", false, "supprimer les documents absents du disque")
flags := addNodeFlags(fs)
if err := fs.Parse(args); err != nil {
return err
}
actorID, err := parseID(*actor, "actor")
if err != nil {
return err
}
parentID, err := parseID(*parent, "parent")
if err != nil {
return err
}
if strings.TrimSpace(*root) == "" {
return errors.New("path requis")
}
n, err := flags.open()
if err != nil {
return err
}
defer n.Close()
result, err := n.Ingest().ImportWithOptions(context.Background(), actorID, parentID, *root, ingest.ScanOptions{Prune: *prune})
if err != nil {
return err
}
if err := printJSON(scanOutputFrom(result)); err != nil {
return err
}
if result.HasErrors() {
return fmt.Errorf("import terminé avec %d erreur(s)", len(result.Errors))
}
return nil
}
type scanOutput struct {
Files int `json:"files"`
Directories int `json:"directories"`
Created int `json:"created"`
Updated int `json:"updated"`
Unchanged int `json:"unchanged"`
Pruned int `json:"pruned"`
Errors []string `json:"errors,omitempty"`
}
func scanOutputFrom(result ingest.ScanResult) scanOutput {
output := scanOutput{
Files: result.Files,
Directories: result.Directories,
Created: result.Created,
Updated: result.Updated,
Unchanged: result.Unchanged,
Pruned: result.Pruned,
}
for _, scanErr := range result.Errors {
output.Errors = append(output.Errors, scanErr.Error())
}
return output
}
func parseID(value, name string) (ident.UUID, error) {
if strings.TrimSpace(value) == "" {
return ident.UUID{}, fmt.Errorf("%s requis", name)
}
id, err := ident.Parse(value)
if err != nil {
return ident.UUID{}, fmt.Errorf("%s invalide: %w", name, err)
}
return id, nil
}
func printJSON(value any) error {
encoder := json.NewEncoder(os.Stdout)
encoder.SetIndent("", " ")
return encoder.Encode(value)
}