api + cli
This commit is contained in:
+409
-7
@@ -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)
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user