425 lines
10 KiB
Go
425 lines
10 KiB
Go
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)
|
|
}
|