package main import ( "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" ) const defaultStoragePolicyID = "00000000-0000-7000-8000-000000000101" 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 { fmt.Fprintln(os.Stderr, err) os.Exit(1) } } 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] 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) }