diff --git a/api/api.go b/api/api.go new file mode 100644 index 0000000..e0e89a9 --- /dev/null +++ b/api/api.go @@ -0,0 +1,56 @@ +package api + +import ( + "net/http" + + "mediarr/node" +) + +type Server struct { + node *node.Node +} + +func NewServer(n *node.Node) *Server { + return &Server{node: n} +} + +func (s *Server) Handler() http.Handler { + mux := http.NewServeMux() + + mux.HandleFunc("GET /api/health", s.handleHealth) + mux.HandleFunc("POST /api/login", s.handleLogin) + + mux.Handle("POST /api/logout", s.requireAuth(http.HandlerFunc(s.handleLogout))) + mux.Handle("GET /api/me", s.requireAuth(http.HandlerFunc(s.handleMe))) + mux.Handle("POST /api/users", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.handleCreateUser)))) + + mux.Handle("GET /api/libraries", s.requireAuth(http.HandlerFunc(s.handleListLibraries))) + mux.Handle("POST /api/libraries", s.requireAuth(http.HandlerFunc(s.handleCreateLibrary))) + + mux.Handle("GET /api/documents/{id}", s.requireAuth(http.HandlerFunc(s.handleGetDocument))) + mux.Handle("GET /api/documents/{id}/children", s.requireAuth(http.HandlerFunc(s.handleListChildren))) + mux.Handle("POST /api/documents/{id}/children", s.requireAuth(http.HandlerFunc(s.handleCreateChild))) + mux.Handle("POST /api/documents/{id}/rename", s.requireAuth(http.HandlerFunc(s.handleRename))) + mux.Handle("PUT /api/documents/{id}/metadata", s.requireAuth(http.HandlerFunc(s.handleSetMetadata))) + mux.Handle("POST /api/documents/{id}/move", s.requireAuth(http.HandlerFunc(s.handleMove))) + mux.Handle("DELETE /api/documents/{id}", s.requireAuth(http.HandlerFunc(s.handleTrash))) + mux.Handle("POST /api/documents/{id}/restore", s.requireAuth(http.HandlerFunc(s.handleRestore))) + + mux.Handle("GET /api/documents/{id}/versions", s.requireAuth(http.HandlerFunc(s.handleListVersions))) + mux.Handle("POST /api/documents/{id}/versions", s.requireAuth(http.HandlerFunc(s.handleUploadVersion))) + mux.Handle("GET /api/documents/{id}/head", s.requireAuth(http.HandlerFunc(s.handleGetHead))) + mux.Handle("POST /api/documents/{id}/head", s.requireAuth(http.HandlerFunc(s.handleSetHead))) + mux.Handle("POST /api/documents/{id}/retention", s.requireAuth(http.HandlerFunc(s.handleApplyRetention))) + + mux.Handle("GET /api/versions/{id}", s.requireAuth(http.HandlerFunc(s.handleDownloadVersion))) + mux.Handle("DELETE /api/versions/{id}", s.requireAuth(http.HandlerFunc(s.handlePurgeVersion))) + mux.Handle("POST /api/versions/{id}/verify", s.requireAuth(http.HandlerFunc(s.handleVerifyVersion))) + + mux.Handle("POST /api/maintenance/gc", s.requireAuth(s.requireAdmin(http.HandlerFunc(s.handleCollectGarbage)))) + + return mux +} + +func (s *Server) handleHealth(w http.ResponseWriter, _ *http.Request) { + writeJSON(w, http.StatusOK, map[string]string{"status": "ok"}) +} diff --git a/api/api_test.go b/api/api_test.go new file mode 100644 index 0000000..aa0e8b2 --- /dev/null +++ b/api/api_test.go @@ -0,0 +1,411 @@ +package api + +import ( + "bytes" + "context" + "encoding/json" + "io" + "mime/multipart" + "net/http" + "net/http/httptest" + "testing" + + "mediarr/auth" + "mediarr/ident" + "mediarr/identity" + "mediarr/node" +) + +type apiTestEnv struct { + node node.Node + server *httptest.Server +} + +func newAPITestEnv(t *testing.T) *apiTestEnv { + t.Helper() + t.Chdir(t.TempDir()) + + err, n := node.NewNode(node.NewNodeParams{ + DatabaseName: "api", + StoragePath: "store", + ClusterKeyPath: "cluster.key", + }) + if err != nil { + t.Fatalf("NewNode : %v", err) + } + t.Cleanup(func() { + if err := n.Close(); err != nil { + t.Errorf("Close : %v", err) + } + }) + + if err := n.Up(); err != nil { + t.Fatalf("Up : %v", err) + } + + server := httptest.NewServer(NewServer(&n).Handler()) + t.Cleanup(server.Close) + + return &apiTestEnv{node: n, server: server} +} + +func TestAPIWorkflow(t *testing.T) { + env := newAPITestEnv(t) + ctx := context.Background() + client := env.server.Client() + + if _, err := env.node.Auth().CreateUser(ctx, auth.CreateUserParams{ + Login: "admin", + Password: "password123", + Role: identity.RoleAdmin, + }); err != nil { + t.Fatalf("CreateUser(admin) : %v", err) + } + + response, body := doJSON(t, client, http.MethodGet, env.server.URL+"/api/health", "", nil) + requireStatus(t, response, body, http.StatusOK) + + response, body = doJSON(t, client, http.MethodGet, env.server.URL+"/api/me", "", nil) + requireStatus(t, response, body, http.StatusUnauthorized) + + response, body = doJSON(t, client, http.MethodPost, env.server.URL+"/api/login", "", map[string]string{ + "login": "admin", + "password": "password123", + }) + requireStatus(t, response, body, http.StatusOK) + login := decodeBody[loginResponse](t, body) + if login.Token == "" || login.Principal.ID == "" || login.Account.Login != "admin" { + t.Fatalf("login = %+v", login) + } + if len(response.Cookies()) == 0 { + t.Fatal("cookie de session absent") + } + token := login.Token + + response, body = doJSON(t, client, http.MethodGet, env.server.URL+"/api/me", token, nil) + requireStatus(t, response, body, http.StatusOK) + me := decodeBody[userDTO](t, body) + if me.Principal.ID != login.Principal.ID || me.Account.Login != "admin" { + t.Fatalf("me = %+v", me) + } + + response, body = doJSON(t, client, http.MethodPost, env.server.URL+"/api/libraries", token, map[string]any{ + "name": "Films", + }) + requireStatus(t, response, body, http.StatusCreated) + library := decodeBody[documentDTO](t, body) + if library.Kind != "library" || library.Name != "Films" || library.PolicyID == nil { + t.Fatalf("bibliothèque = %+v", library) + } + + response, body = doJSON(t, client, http.MethodGet, env.server.URL+"/api/libraries", token, nil) + requireStatus(t, response, body, http.StatusOK) + libraries := decodeBody[[]documentDTO](t, body) + if len(libraries) != 1 || libraries[0].ID != library.ID { + t.Fatalf("bibliothèques = %+v", libraries) + } + + response, body = doJSON(t, client, http.MethodPost, env.server.URL+"/api/documents/"+library.ID+"/children", token, map[string]any{ + "kind": "video", + "name": "film.mkv", + }) + requireStatus(t, response, body, http.StatusCreated) + video := decodeBody[documentDTO](t, body) + if video.Kind != "video" || video.ParentID == nil || *video.ParentID != library.ID { + t.Fatalf("vidéo = %+v", video) + } + + response, body = doUpload(t, client, env.server.URL+"/api/documents/"+video.ID+"/versions", token, "film.mkv", []byte("contenu v1")) + requireStatus(t, response, body, http.StatusCreated) + first := decodeBody[versionDTO](t, body) + if first.Seq != 1 || first.Size != int64(len("contenu v1")) || first.DocumentID != video.ID { + t.Fatalf("version 1 = %+v", first) + } + + response, body = doJSON(t, client, http.MethodGet, env.server.URL+"/api/documents/"+video.ID+"/versions", token, nil) + requireStatus(t, response, body, http.StatusOK) + versions := decodeBody[[]versionDTO](t, body) + if len(versions) != 1 || versions[0].ID != first.ID { + t.Fatalf("versions = %+v", versions) + } + + response, body = doJSON(t, client, http.MethodGet, env.server.URL+"/api/documents/"+video.ID+"/head", token, nil) + requireStatus(t, response, body, http.StatusOK) + head := decodeBody[struct { + Version *versionDTO `json:"version"` + }](t, body) + if head.Version == nil || head.Version.ID != first.ID { + t.Fatalf("head = %+v", head) + } + + response, downloaded := doRaw(t, client, http.MethodGet, env.server.URL+"/api/versions/"+first.ID, token, nil, "") + requireStatus(t, response, downloaded, http.StatusOK) + if string(downloaded) != "contenu v1" { + t.Fatalf("contenu téléchargé = %q", downloaded) + } + + response, body = doJSON(t, client, http.MethodPost, env.server.URL+"/api/documents/"+video.ID+"/head", token, map[string]string{ + "version_id": first.ID, + }) + requireStatus(t, response, body, http.StatusOK) + if decodeBody[versionDTO](t, body).ID != first.ID { + t.Fatal("version tête incohérente") + } + + response, body = doUpload(t, client, env.server.URL+"/api/documents/"+video.ID+"/versions", token, "film.mkv", []byte("contenu v2")) + requireStatus(t, response, body, http.StatusCreated) + second := decodeBody[versionDTO](t, body) + if second.Seq != 2 { + t.Fatalf("version 2 = %+v", second) + } + + response, body = doJSON(t, client, http.MethodPost, env.server.URL+"/api/documents/"+video.ID+"/head", token, map[string]string{ + "version_id": second.ID, + }) + requireStatus(t, response, body, http.StatusOK) + + response, body = doJSON(t, client, http.MethodDelete, env.server.URL+"/api/versions/"+first.ID, token, nil) + requireStatus(t, response, body, http.StatusNoContent) + + response, body = doJSON(t, client, http.MethodGet, env.server.URL+"/api/versions/"+first.ID, token, nil) + requireStatus(t, response, body, http.StatusGone) + + response, body = doJSON(t, client, http.MethodPost, env.server.URL+"/api/documents/"+video.ID+"/retention", token, nil) + requireStatus(t, response, body, http.StatusOK) + retention := decodeBody[retentionDTO](t, body) + if retention.Kept < 1 { + t.Fatalf("rétention = %+v", retention) + } + + response, body = doJSON(t, client, http.MethodPost, env.server.URL+"/api/versions/"+second.ID+"/verify", token, nil) + requireStatus(t, response, body, http.StatusNoContent) + + response, body = doJSON(t, client, http.MethodPost, env.server.URL+"/api/documents/"+video.ID+"/rename", token, map[string]string{ + "name": "film-renamed.mkv", + }) + requireStatus(t, response, body, http.StatusOK) + if decodeBody[documentDTO](t, body).Name != "film-renamed.mkv" { + t.Fatal("renommage incohérent") + } + + response, body = doJSON(t, client, http.MethodPut, env.server.URL+"/api/documents/"+video.ID+"/metadata", token, map[string]any{ + "metadata": map[string]any{"tag": "test"}, + }) + requireStatus(t, response, body, http.StatusOK) + if string(decodeBody[documentDTO](t, body).Metadata) != `{"tag":"test"}` { + t.Fatalf("métadonnées = %s", body) + } + + response, body = doJSON(t, client, http.MethodPost, env.server.URL+"/api/documents/"+library.ID+"/children", token, map[string]any{ + "kind": "folder", + "name": "Dossier", + }) + requireStatus(t, response, body, http.StatusCreated) + folder := decodeBody[documentDTO](t, body) + + response, body = doJSON(t, client, http.MethodPost, env.server.URL+"/api/documents/"+video.ID+"/move", token, map[string]string{ + "parent_id": folder.ID, + }) + requireStatus(t, response, body, http.StatusOK) + moved := decodeBody[documentDTO](t, body) + if moved.ParentID == nil || *moved.ParentID != folder.ID { + t.Fatalf("déplacement = %+v", moved) + } + + response, body = doJSON(t, client, http.MethodDelete, env.server.URL+"/api/documents/"+video.ID, token, nil) + requireStatus(t, response, body, http.StatusOK) + trashed := decodeBody[documentDTO](t, body) + if trashed.DeletedAt == nil { + t.Fatal("document non mis à la corbeille") + } + + response, body = doJSON(t, client, http.MethodPost, env.server.URL+"/api/documents/"+video.ID+"/restore", token, nil) + requireStatus(t, response, body, http.StatusOK) + if decodeBody[documentDTO](t, body).DeletedAt != nil { + t.Fatal("document non restauré") + } + + response, body = doJSON(t, client, http.MethodPost, env.server.URL+"/api/users", token, map[string]string{ + "login": "member", + "password": "password123", + "role": identity.RoleMember, + }) + requireStatus(t, response, body, http.StatusCreated) + + response, body = doJSON(t, client, http.MethodPost, env.server.URL+"/api/login", "", map[string]string{ + "login": "member", + "password": "password123", + }) + requireStatus(t, response, body, http.StatusOK) + memberToken := decodeBody[loginResponse](t, body).Token + + response, body = doJSON(t, client, http.MethodPost, env.server.URL+"/api/maintenance/gc", memberToken, nil) + requireStatus(t, response, body, http.StatusForbidden) + + response, body = doJSON(t, client, http.MethodPost, env.server.URL+"/api/maintenance/gc", token, nil) + requireStatus(t, response, body, http.StatusOK) + + response, body = doJSON(t, client, http.MethodPost, env.server.URL+"/api/logout", token, nil) + requireStatus(t, response, body, http.StatusNoContent) + + response, body = doJSON(t, client, http.MethodGet, env.server.URL+"/api/me", token, nil) + requireStatus(t, response, body, http.StatusUnauthorized) +} + +func TestAPILoginRejectsInvalidCredentials(t *testing.T) { + env := newAPITestEnv(t) + client := env.server.Client() + + response, body := doJSON(t, client, http.MethodPost, env.server.URL+"/api/login", "", map[string]string{ + "login": "missing", + "password": "password123", + }) + requireStatus(t, response, body, http.StatusUnauthorized) +} + +func TestAPIDocumentNotFound(t *testing.T) { + env := newAPITestEnv(t) + ctx := context.Background() + client := env.server.Client() + + if _, err := env.node.Auth().CreateUser(ctx, auth.CreateUserParams{ + Login: "admin", + Password: "password123", + Role: identity.RoleAdmin, + }); err != nil { + t.Fatalf("CreateUser : %v", err) + } + + _, body := doJSON(t, client, http.MethodPost, env.server.URL+"/api/login", "", map[string]string{ + "login": "admin", + "password": "password123", + }) + token := decodeBody[loginResponse](t, body).Token + + missing := ident.MustParse("00000000-0000-7000-8000-000000000999").String() + response, body := doJSON(t, client, http.MethodGet, env.server.URL+"/api/documents/"+missing, token, nil) + requireStatus(t, response, body, http.StatusNotFound) +} + +func doJSON(t *testing.T, client *http.Client, method, url, token string, body any) (*http.Response, []byte) { + t.Helper() + + var reader io.Reader + if body != nil { + encoded, err := json.Marshal(body) + if err != nil { + t.Fatalf("Marshal : %v", err) + } + reader = bytes.NewReader(encoded) + } + + request, err := http.NewRequest(method, url, reader) + if err != nil { + t.Fatalf("NewRequest : %v", err) + } + if body != nil { + request.Header.Set("Content-Type", "application/json") + } + if token != "" { + request.Header.Set("Authorization", "Bearer "+token) + } + + response, err := client.Do(request) + if err != nil { + t.Fatalf("%s %s : %v", method, url, err) + } + data, err := io.ReadAll(response.Body) + if err != nil { + _ = response.Body.Close() + t.Fatalf("ReadAll : %v", err) + } + _ = response.Body.Close() + + return response, data +} + +func doUpload(t *testing.T, client *http.Client, url, token, filename string, content []byte) (*http.Response, []byte) { + t.Helper() + + body := &bytes.Buffer{} + writer := multipart.NewWriter(body) + part, err := writer.CreateFormFile("file", filename) + if err != nil { + t.Fatalf("CreateFormFile : %v", err) + } + if _, err := part.Write(content); err != nil { + t.Fatalf("Write : %v", err) + } + if err := writer.WriteField("message", "test"); err != nil { + t.Fatalf("WriteField : %v", err) + } + if err := writer.Close(); err != nil { + t.Fatalf("Close : %v", err) + } + + request, err := http.NewRequest(http.MethodPost, url, body) + if err != nil { + t.Fatalf("NewRequest : %v", err) + } + request.Header.Set("Content-Type", writer.FormDataContentType()) + request.Header.Set("Authorization", "Bearer "+token) + + response, err := client.Do(request) + if err != nil { + t.Fatalf("POST %s : %v", url, err) + } + data, err := io.ReadAll(response.Body) + if err != nil { + _ = response.Body.Close() + t.Fatalf("ReadAll : %v", err) + } + _ = response.Body.Close() + + return response, data +} + +func doRaw(t *testing.T, client *http.Client, method, url, token string, body io.Reader, contentType string) (*http.Response, []byte) { + t.Helper() + + request, err := http.NewRequest(method, url, body) + if err != nil { + t.Fatalf("NewRequest : %v", err) + } + if contentType != "" { + request.Header.Set("Content-Type", contentType) + } + if token != "" { + request.Header.Set("Authorization", "Bearer "+token) + } + + response, err := client.Do(request) + if err != nil { + t.Fatalf("%s %s : %v", method, url, err) + } + data, err := io.ReadAll(response.Body) + if err != nil { + _ = response.Body.Close() + t.Fatalf("ReadAll : %v", err) + } + _ = response.Body.Close() + + return response, data +} + +func decodeBody[T any](t *testing.T, body []byte) T { + t.Helper() + + var value T + if err := json.Unmarshal(body, &value); err != nil { + t.Fatalf("Unmarshal %s : %v", body, err) + } + return value +} + +func requireStatus(t *testing.T, response *http.Response, body []byte, want int) { + t.Helper() + + if response.StatusCode != want { + t.Fatalf("status = %d, attendu %d: %s", response.StatusCode, want, body) + } +} diff --git a/api/auth.go b/api/auth.go new file mode 100644 index 0000000..575f661 --- /dev/null +++ b/api/auth.go @@ -0,0 +1,262 @@ +package api + +import ( + "context" + "errors" + "net/http" + "strings" + "time" + + "mediarr/auth" + "mediarr/identity" +) + +const sessionCookieName = "mediarr_session" + +type contextKey int + +const ( + userContextKey contextKey = iota + tokenContextKey +) + +type loginRequest struct { + Login string `json:"login"` + Password string `json:"password"` + Label string `json:"label,omitempty"` +} + +type loginResponse struct { + Token string `json:"token"` + Principal principalDTO `json:"principal"` + Account accountDTO `json:"account"` +} + +type createUserRequest struct { + Login string `json:"login"` + Password string `json:"password"` + Role string `json:"role,omitempty"` +} + +type userDTO struct { + Principal principalDTO `json:"principal"` + Account accountDTO `json:"account"` +} + +type principalDTO struct { + ID string `json:"id"` + Kind string `json:"kind"` + Name string `json:"name"` + Status string `json:"status"` + CreatedAt int64 `json:"created_at"` + Groups []groupDTO `json:"groups"` +} + +type groupDTO struct { + ID string `json:"id"` + Name string `json:"name"` + Status string `json:"status"` + Role string `json:"role"` +} + +type accountDTO struct { + Login string `json:"login"` + State string `json:"state"` + MustChangePassword bool `json:"must_change_password"` + LastLoginAt *int64 `json:"last_login_at,omitempty"` +} + +func (s *Server) handleLogin(w http.ResponseWriter, r *http.Request) { + var request loginRequest + if err := decodeJSON(w, r, &request); err != nil { + writeErrorFor(w, err) + return + } + + user, err := s.node.Auth().Authenticate(r.Context(), request.Login, request.Password) + if err != nil { + writeErrorFor(w, err) + return + } + + _, token, err := s.node.Auth().CreateSession(r.Context(), auth.CreateSessionParams{ + PrincipalID: user.Principal.ID, + Kind: "web", + Label: request.Label, + UserAgent: r.UserAgent(), + }) + if err != nil { + writeErrorFor(w, err) + return + } + + http.SetCookie(w, &http.Cookie{ + Name: sessionCookieName, + Value: token, + Path: "/", + MaxAge: int((30 * 24 * time.Hour).Seconds()), + HttpOnly: true, + SameSite: http.SameSiteLaxMode, + }) + + dto := userDTOFrom(user) + writeJSON(w, http.StatusOK, loginResponse{ + Token: token, + Principal: dto.Principal, + Account: dto.Account, + }) +} + +func (s *Server) handleLogout(w http.ResponseWriter, r *http.Request) { + token := currentToken(r) + if token != "" { + if err := s.node.Auth().RevokeSessionByToken(r.Context(), token); err != nil && !errors.Is(err, auth.ErrInvalidSession) { + writeErrorFor(w, err) + return + } + } + + http.SetCookie(w, &http.Cookie{ + Name: sessionCookieName, + Value: "", + Path: "/", + MaxAge: -1, + HttpOnly: true, + SameSite: http.SameSiteLaxMode, + }) + w.WriteHeader(http.StatusNoContent) +} + +func (s *Server) handleMe(w http.ResponseWriter, r *http.Request) { + user := currentUser(r) + if user == nil { + writeError(w, http.StatusUnauthorized, auth.ErrInvalidSession.Error()) + return + } + writeJSON(w, http.StatusOK, userDTOFrom(user)) +} + +func (s *Server) handleCreateUser(w http.ResponseWriter, r *http.Request) { + var request createUserRequest + if err := decodeJSON(w, r, &request); err != nil { + writeErrorFor(w, err) + return + } + + role := request.Role + if role == "" { + role = identity.RoleMember + } + + created, err := s.node.Auth().CreateUser(r.Context(), auth.CreateUserParams{ + Login: request.Login, + Password: request.Password, + Role: role, + }) + if err != nil { + writeErrorFor(w, err) + return + } + + writeJSON(w, http.StatusCreated, userDTOFrom(created)) +} + +func (s *Server) requireAuth(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + token := extractToken(r) + if token == "" { + writeError(w, http.StatusUnauthorized, auth.ErrInvalidSession.Error()) + return + } + + _, user, err := s.node.Auth().ValidateSession(r.Context(), token) + if err != nil { + writeErrorFor(w, err) + return + } + + ctx := context.WithValue(r.Context(), userContextKey, user) + ctx = context.WithValue(ctx, tokenContextKey, token) + next.ServeHTTP(w, r.WithContext(ctx)) + }) +} + +func (s *Server) requireAdmin(next http.Handler) http.Handler { + return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + user := currentUser(r) + if user == nil || !isAdmin(user) { + writeError(w, http.StatusForbidden, "droits administrateur requis") + return + } + next.ServeHTTP(w, r) + }) +} + +func extractToken(r *http.Request) string { + if header := r.Header.Get("Authorization"); header != "" { + if strings.HasPrefix(strings.ToLower(header), "bearer ") { + return strings.TrimSpace(header[len("bearer "):]) + } + return "" + } + + cookie, err := r.Cookie(sessionCookieName) + if err != nil { + return "" + } + return cookie.Value +} + +func currentUser(r *http.Request) *auth.AuthenticatedUser { + user, _ := r.Context().Value(userContextKey).(*auth.AuthenticatedUser) + return user +} + +func currentToken(r *http.Request) string { + token, _ := r.Context().Value(tokenContextKey).(string) + return token +} + +func isAdmin(user *auth.AuthenticatedUser) bool { + for _, group := range user.Principal.Groups { + if group.Role == identity.RoleAdmin || group.Name == "admins" { + return true + } + } + return false +} + +func userDTOFrom(user *auth.AuthenticatedUser) userDTO { + groups := make([]groupDTO, 0, len(user.Principal.Groups)) + for _, group := range user.Principal.Groups { + groups = append(groups, groupDTO{ + ID: group.ID.String(), + Name: group.Name, + Status: group.Status, + Role: group.Role, + }) + } + + var lastLoginAt *int64 + if user.Account.LastLoginAt.Valid { + value := user.Account.LastLoginAt.Int64 + lastLoginAt = &value + } + + return userDTO{ + Principal: principalDTO{ + ID: user.Principal.ID.String(), + Kind: user.Principal.Kind, + Name: user.Principal.Name, + Status: user.Principal.Status, + CreatedAt: user.Principal.CreatedAt, + Groups: groups, + }, + Account: accountDTO{ + Login: user.Account.Login, + State: user.Account.State, + MustChangePassword: user.Account.MustChangePassword, + LastLoginAt: lastLoginAt, + }, + } +} diff --git a/api/content.go b/api/content.go new file mode 100644 index 0000000..92fbbb4 --- /dev/null +++ b/api/content.go @@ -0,0 +1,284 @@ +package api + +import ( + "encoding/hex" + "fmt" + "io" + "mime" + "net/http" + "path/filepath" + "strconv" + "strings" + + "mediarr/content" + "mediarr/ident" +) + +type versionDTO struct { + ID string `json:"id"` + DocumentID string `json:"document_id"` + Seq int64 `json:"seq"` + ContentRoot string `json:"content_root"` + Size int64 `json:"size"` + Mime string `json:"mime,omitempty"` + AuthorID string `json:"author_id"` + Origin string `json:"origin"` + Message string `json:"message,omitempty"` + Pinned bool `json:"pinned"` + ContentPurgedAt *int64 `json:"content_purged_at,omitempty"` + CreatedAt int64 `json:"created_at"` +} + +type setHeadRequest struct { + VersionID string `json:"version_id"` +} + +type retentionDTO struct { + Purged []string `json:"purged"` + Kept int `json:"kept"` +} + +type garbageCollectionDTO struct { + Blobs int `json:"blobs"` + Locations int `json:"locations"` + Bytes int64 `json:"bytes"` +} + +func (s *Server) handleListVersions(w http.ResponseWriter, r *http.Request) { + documentID, err := idParam(r, "id") + if err != nil { + writeErrorFor(w, err) + return + } + + versions, err := s.node.Content().ListVersions(r.Context(), actorID(r), documentID) + if err != nil { + writeErrorFor(w, err) + return + } + + result := make([]versionDTO, 0, len(versions)) + for i := range versions { + result = append(result, versionDTOFrom(&versions[i])) + } + writeJSON(w, http.StatusOK, result) +} + +func (s *Server) handleUploadVersion(w http.ResponseWriter, r *http.Request) { + documentID, err := idParam(r, "id") + if err != nil { + writeErrorFor(w, err) + return + } + + r.Body = http.MaxBytesReader(w, r.Body, maxUploadBody) + defer func() { + if r.MultipartForm != nil { + _ = r.MultipartForm.RemoveAll() + } + }() + + file, header, err := r.FormFile("file") + if err != nil { + writeError(w, http.StatusBadRequest, "fichier requis") + return + } + defer file.Close() + + origin := r.FormValue("origin") + if origin == "" { + origin = content.OriginUpload + } + if origin != content.OriginUpload && origin != content.OriginRestore { + writeError(w, http.StatusBadRequest, "origine invalide") + return + } + + mimeType := strings.TrimSpace(r.FormValue("mime")) + if mimeType == "" { + mimeType = mime.TypeByExtension(strings.ToLower(filepath.Ext(header.Filename))) + } + if mimeType == "" { + mimeType = "application/octet-stream" + } + + pinned := false + if raw := r.FormValue("pinned"); raw != "" { + parsed, err := strconv.ParseBool(raw) + if err != nil { + writeError(w, http.StatusBadRequest, "pinned invalide") + return + } + pinned = parsed + } + + version, err := s.node.Content().CreateVersion(r.Context(), actorID(r), documentID, content.CreateVersionParams{ + Source: file, + Mime: mimeType, + Origin: origin, + Message: r.FormValue("message"), + Pinned: pinned, + }) + if err != nil { + writeErrorFor(w, err) + return + } + + w.Header().Set("Location", "/api/versions/"+version.ID.String()) + writeJSON(w, http.StatusCreated, versionDTOFrom(version)) +} + +func (s *Server) handleDownloadVersion(w http.ResponseWriter, r *http.Request) { + versionID, err := idParam(r, "id") + if err != nil { + writeErrorFor(w, err) + return + } + + reader, version, err := s.node.Content().OpenVersion(r.Context(), actorID(r), versionID) + if err != nil { + writeErrorFor(w, err) + return + } + defer reader.Close() + + contentType := version.Mime + if contentType == "" { + contentType = "application/octet-stream" + } + w.Header().Set("Content-Type", contentType) + w.Header().Set("Content-Length", strconv.FormatInt(version.Size, 10)) + w.Header().Set("Content-Disposition", fmt.Sprintf("attachment; filename=%q", fmt.Sprintf("version-%d", version.Seq))) + w.WriteHeader(http.StatusOK) + _, _ = io.Copy(w, reader) +} + +func (s *Server) handleGetHead(w http.ResponseWriter, r *http.Request) { + documentID, err := idParam(r, "id") + if err != nil { + writeErrorFor(w, err) + return + } + + version, err := s.node.Content().HeadVersion(r.Context(), actorID(r), documentID) + if err != nil { + writeErrorFor(w, err) + return + } + + if version == nil { + writeJSON(w, http.StatusOK, map[string]any{"version": nil}) + return + } + writeJSON(w, http.StatusOK, map[string]any{"version": versionDTOFrom(version)}) +} + +func (s *Server) handleSetHead(w http.ResponseWriter, r *http.Request) { + documentID, err := idParam(r, "id") + if err != nil { + writeErrorFor(w, err) + return + } + + var request setHeadRequest + if err := decodeJSON(w, r, &request); err != nil { + writeErrorFor(w, err) + return + } + + versionID, err := ident.Parse(request.VersionID) + if err != nil { + writeError(w, http.StatusBadRequest, "version_id invalide") + return + } + + version, err := s.node.Content().SetHeadVersion(r.Context(), actorID(r), documentID, versionID) + if err != nil { + writeErrorFor(w, err) + return + } + + writeJSON(w, http.StatusOK, versionDTOFrom(version)) +} + +func (s *Server) handleApplyRetention(w http.ResponseWriter, r *http.Request) { + documentID, err := idParam(r, "id") + if err != nil { + writeErrorFor(w, err) + return + } + + result, err := s.node.Content().ApplyRetention(r.Context(), actorID(r), documentID) + if err != nil { + writeErrorFor(w, err) + return + } + + purged := make([]string, 0, len(result.Purged)) + for _, id := range result.Purged { + purged = append(purged, id.String()) + } + + writeJSON(w, http.StatusOK, retentionDTO{Purged: purged, Kept: result.Kept}) +} + +func (s *Server) handlePurgeVersion(w http.ResponseWriter, r *http.Request) { + versionID, err := idParam(r, "id") + if err != nil { + writeErrorFor(w, err) + return + } + + if err := s.node.Content().PurgeVersion(r.Context(), actorID(r), versionID); err != nil { + writeErrorFor(w, err) + return + } + + w.WriteHeader(http.StatusNoContent) +} + +func (s *Server) handleVerifyVersion(w http.ResponseWriter, r *http.Request) { + versionID, err := idParam(r, "id") + if err != nil { + writeErrorFor(w, err) + return + } + + if err := s.node.Content().VerifyVersion(r.Context(), actorID(r), versionID); err != nil { + writeErrorFor(w, err) + return + } + + w.WriteHeader(http.StatusNoContent) +} + +func (s *Server) handleCollectGarbage(w http.ResponseWriter, r *http.Request) { + result, err := s.node.Content().CollectGarbage(r.Context()) + if err != nil { + writeErrorFor(w, err) + return + } + + writeJSON(w, http.StatusOK, garbageCollectionDTO{ + Blobs: result.Blobs, + Locations: result.Locations, + Bytes: result.Bytes, + }) +} + +func versionDTOFrom(version *content.Version) versionDTO { + return versionDTO{ + ID: version.ID.String(), + DocumentID: version.DocumentID.String(), + Seq: version.Seq, + ContentRoot: hex.EncodeToString(version.ContentRoot), + Size: version.Size, + Mime: version.Mime, + AuthorID: version.AuthorID.String(), + Origin: version.Origin, + Message: version.Message, + Pinned: version.Pinned, + ContentPurgedAt: version.ContentPurgedAt, + CreatedAt: version.CreatedAt, + } +} diff --git a/api/documents.go b/api/documents.go new file mode 100644 index 0000000..81a8fda --- /dev/null +++ b/api/documents.go @@ -0,0 +1,338 @@ +package api + +import ( + "encoding/json" + "net/http" + + "mediarr/document" + "mediarr/ident" +) + +const defaultStoragePolicyID = "00000000-0000-7000-8000-000000000101" + +type documentDTO struct { + ID string `json:"id"` + Kind string `json:"kind"` + OwnerID string `json:"owner_id"` + CreatedBy string `json:"created_by"` + ParentID *string `json:"parent_id,omitempty"` + Name string `json:"name"` + Path string `json:"path"` + Depth int64 `json:"depth"` + HeadVersionID *string `json:"head_version_id,omitempty"` + Metadata json.RawMessage `json:"metadata"` + PolicyID *string `json:"policy_id,omitempty"` + Visibility string `json:"visibility,omitempty"` + ACLInherit bool `json:"acl_inherit"` + Rev int64 `json:"rev"` + CreatedAt int64 `json:"created_at"` + UpdatedAt int64 `json:"updated_at"` + DeletedAt *int64 `json:"deleted_at,omitempty"` +} + +type createLibraryRequest struct { + Name string `json:"name"` + PolicyID string `json:"policy_id,omitempty"` + Visibility string `json:"visibility,omitempty"` + ACLInherit *bool `json:"acl_inherit,omitempty"` + Metadata json.RawMessage `json:"metadata,omitempty"` +} + +type createChildRequest struct { + Kind string `json:"kind"` + Name string `json:"name"` + ACLInherit *bool `json:"acl_inherit,omitempty"` + Metadata json.RawMessage `json:"metadata,omitempty"` +} + +type renameRequest struct { + Name string `json:"name"` +} + +type metadataRequest struct { + Metadata json.RawMessage `json:"metadata"` +} + +type moveRequest struct { + ParentID string `json:"parent_id"` +} + +func (s *Server) handleListLibraries(w http.ResponseWriter, r *http.Request) { + libraries, err := s.node.Documents().ListLibraries(r.Context(), actorID(r)) + if err != nil { + writeErrorFor(w, err) + return + } + + writeJSON(w, http.StatusOK, documentsDTO(libraries)) +} + +func (s *Server) handleCreateLibrary(w http.ResponseWriter, r *http.Request) { + var request createLibraryRequest + if err := decodeJSON(w, r, &request); err != nil { + writeErrorFor(w, err) + return + } + + policyID := request.PolicyID + if policyID == "" { + policyID = defaultStoragePolicyID + } + parsedPolicyID, err := ident.Parse(policyID) + if err != nil { + writeError(w, http.StatusBadRequest, "policy_id invalide") + return + } + + metadata, err := metadataString(request.Metadata) + if err != nil { + writeErrorFor(w, err) + return + } + + created, err := s.node.Documents().CreateLibrary(r.Context(), actorID(r), document.CreateLibraryParams{ + OwnerID: actorID(r), + CreatedBy: actorID(r), + Name: request.Name, + PolicyID: parsedPolicyID, + Visibility: request.Visibility, + ACLInherit: request.ACLInherit, + Metadata: metadata, + }) + if err != nil { + writeErrorFor(w, err) + return + } + + w.Header().Set("Location", "/api/documents/"+created.ID.String()) + writeJSON(w, http.StatusCreated, documentDTOFrom(created)) +} + +func (s *Server) handleGetDocument(w http.ResponseWriter, r *http.Request) { + id, err := idParam(r, "id") + if err != nil { + writeErrorFor(w, err) + return + } + + found, err := s.node.Documents().Get(r.Context(), actorID(r), id) + if err != nil { + writeErrorFor(w, err) + return + } + + writeJSON(w, http.StatusOK, documentDTOFrom(found)) +} + +func (s *Server) handleListChildren(w http.ResponseWriter, r *http.Request) { + id, err := idParam(r, "id") + if err != nil { + writeErrorFor(w, err) + return + } + + children, err := s.node.Documents().ListChildren(r.Context(), actorID(r), id) + if err != nil { + writeErrorFor(w, err) + return + } + + writeJSON(w, http.StatusOK, documentsDTO(children)) +} + +func (s *Server) handleCreateChild(w http.ResponseWriter, r *http.Request) { + parentID, err := idParam(r, "id") + if err != nil { + writeErrorFor(w, err) + return + } + + var request createChildRequest + if err := decodeJSON(w, r, &request); err != nil { + writeErrorFor(w, err) + return + } + + metadata, err := metadataString(request.Metadata) + if err != nil { + writeErrorFor(w, err) + return + } + + created, err := s.node.Documents().CreateChild(r.Context(), actorID(r), document.CreateChildParams{ + Kind: request.Kind, + OwnerID: actorID(r), + CreatedBy: actorID(r), + ParentID: parentID, + Name: request.Name, + ACLInherit: request.ACLInherit, + Metadata: metadata, + }) + if err != nil { + writeErrorFor(w, err) + return + } + + w.Header().Set("Location", "/api/documents/"+created.ID.String()) + writeJSON(w, http.StatusCreated, documentDTOFrom(created)) +} + +func (s *Server) handleRename(w http.ResponseWriter, r *http.Request) { + id, err := idParam(r, "id") + if err != nil { + writeErrorFor(w, err) + return + } + + var request renameRequest + if err := decodeJSON(w, r, &request); err != nil { + writeErrorFor(w, err) + return + } + + updated, err := s.node.Documents().Rename(r.Context(), actorID(r), id, request.Name) + if err != nil { + writeErrorFor(w, err) + return + } + + writeJSON(w, http.StatusOK, documentDTOFrom(updated)) +} + +func (s *Server) handleSetMetadata(w http.ResponseWriter, r *http.Request) { + id, err := idParam(r, "id") + if err != nil { + writeErrorFor(w, err) + return + } + + var request metadataRequest + if err := decodeJSON(w, r, &request); err != nil { + writeErrorFor(w, err) + return + } + + metadata, err := metadataString(request.Metadata) + if err != nil { + writeErrorFor(w, err) + return + } + + updated, err := s.node.Documents().SetMetadata(r.Context(), actorID(r), id, metadata) + if err != nil { + writeErrorFor(w, err) + return + } + + writeJSON(w, http.StatusOK, documentDTOFrom(updated)) +} + +func (s *Server) handleMove(w http.ResponseWriter, r *http.Request) { + id, err := idParam(r, "id") + if err != nil { + writeErrorFor(w, err) + return + } + + var request moveRequest + if err := decodeJSON(w, r, &request); err != nil { + writeErrorFor(w, err) + return + } + + parentID, err := ident.Parse(request.ParentID) + if err != nil { + writeError(w, http.StatusBadRequest, "parent_id invalide") + return + } + + moved, err := s.node.Documents().Move(r.Context(), actorID(r), id, parentID) + if err != nil { + writeErrorFor(w, err) + return + } + + writeJSON(w, http.StatusOK, documentDTOFrom(moved)) +} + +func (s *Server) handleTrash(w http.ResponseWriter, r *http.Request) { + id, err := idParam(r, "id") + if err != nil { + writeErrorFor(w, err) + return + } + + trashed, err := s.node.Documents().Trash(r.Context(), actorID(r), id) + if err != nil { + writeErrorFor(w, err) + return + } + + writeJSON(w, http.StatusOK, documentDTOFrom(trashed)) +} + +func (s *Server) handleRestore(w http.ResponseWriter, r *http.Request) { + id, err := idParam(r, "id") + if err != nil { + writeErrorFor(w, err) + return + } + + restored, err := s.node.Documents().Restore(r.Context(), actorID(r), id) + if err != nil { + writeErrorFor(w, err) + return + } + + writeJSON(w, http.StatusOK, documentDTOFrom(restored)) +} + +func actorID(r *http.Request) ident.UUID { + user := currentUser(r) + if user == nil { + return ident.UUID{} + } + return user.Principal.ID +} + +func documentsDTO(documents []document.Document) []documentDTO { + result := make([]documentDTO, 0, len(documents)) + for i := range documents { + result = append(result, documentDTOFrom(&documents[i])) + } + return result +} + +func documentDTOFrom(doc *document.Document) documentDTO { + dto := documentDTO{ + ID: doc.ID.String(), + Kind: doc.Kind, + OwnerID: doc.OwnerID.String(), + CreatedBy: doc.CreatedBy.String(), + Name: doc.Name, + Path: doc.Path, + Depth: doc.Depth, + Metadata: json.RawMessage(doc.Metadata), + Visibility: doc.Visibility, + ACLInherit: doc.ACLInherit, + Rev: doc.Rev, + CreatedAt: doc.CreatedAt, + UpdatedAt: doc.UpdatedAt, + DeletedAt: doc.DeletedAt, + } + + if doc.ParentID != nil { + value := doc.ParentID.String() + dto.ParentID = &value + } + if doc.HeadVersionID != nil { + value := doc.HeadVersionID.String() + dto.HeadVersionID = &value + } + if doc.PolicyID != nil { + value := doc.PolicyID.String() + dto.PolicyID = &value + } + + return dto +} diff --git a/api/json.go b/api/json.go new file mode 100644 index 0000000..44c635d --- /dev/null +++ b/api/json.go @@ -0,0 +1,149 @@ +package api + +import ( + "encoding/json" + "errors" + "fmt" + "io" + "net/http" + + "mediarr/auth" + "mediarr/content" + "mediarr/document" + "mediarr/ident" + "mediarr/identity" + "mediarr/storage" +) + +const ( + maxJSONBody = 1 << 20 + maxUploadBody = 2 << 30 +) + +func writeJSON(w http.ResponseWriter, status int, value any) { + w.Header().Set("Content-Type", "application/json; charset=utf-8") + w.WriteHeader(status) + if status == http.StatusNoContent { + return + } + _ = json.NewEncoder(w).Encode(value) +} + +func writeError(w http.ResponseWriter, status int, message string) { + if message == "" { + message = http.StatusText(status) + } + writeJSON(w, status, map[string]string{"error": message}) +} + +func writeErrorFor(w http.ResponseWriter, err error) { + status := statusForError(err) + message := err.Error() + switch status { + case http.StatusInternalServerError: + message = "erreur interne" + case http.StatusRequestEntityTooLarge: + message = "requête trop volumineuse" + } + writeError(w, status, message) +} + +func statusForError(err error) int { + var maxBytes *http.MaxBytesError + if errors.As(err, &maxBytes) { + return http.StatusRequestEntityTooLarge + } + + switch { + case errors.Is(err, auth.ErrInvalidCredentials), + errors.Is(err, auth.ErrInvalidSession): + return http.StatusUnauthorized + case errors.Is(err, auth.ErrAccountLocked), + errors.Is(err, auth.ErrAccountDisabled), + errors.Is(err, document.ErrPermissionDenied): + return http.StatusForbidden + case errors.Is(err, document.ErrDocumentNotFound), + errors.Is(err, document.ErrParentNotFound), + errors.Is(err, document.ErrPolicyNotFound), + errors.Is(err, content.ErrVersionNotFound), + errors.Is(err, content.ErrContentUnavailable), + errors.Is(err, storage.ErrNotFound): + return http.StatusNotFound + case errors.Is(err, document.ErrNameTaken), + errors.Is(err, document.ErrDocumentDeleted), + errors.Is(err, document.ErrParentDeleted), + errors.Is(err, auth.ErrLoginTaken), + errors.Is(err, content.ErrVersionIsHead), + errors.Is(err, content.ErrVersionMismatch), + errors.Is(err, content.ErrBlobUnavailable), + errors.Is(err, content.ErrBlobCorrupt): + return http.StatusConflict + case errors.Is(err, content.ErrContentPurged): + return http.StatusGone + case errors.Is(err, content.ErrStorageNotConfigured), + errors.Is(err, content.ErrStorageBackendMissing): + return http.StatusServiceUnavailable + case errors.Is(err, document.ErrInvalidName), + errors.Is(err, document.ErrInvalidKind), + errors.Is(err, document.ErrInvalidMetadata), + errors.Is(err, document.ErrInvalidParent), + errors.Is(err, document.ErrInvalidMove), + errors.Is(err, document.ErrCannotMoveRoot), + errors.Is(err, document.ErrInvalidVisibility), + errors.Is(err, document.ErrInvalidTrashBatch), + errors.Is(err, auth.ErrInvalidLogin), + errors.Is(err, auth.ErrWeakPassword), + errors.Is(err, identity.ErrInvalidRole), + errors.Is(err, content.ErrInvalidOrigin), + errors.Is(err, content.ErrInvalidSource), + errors.Is(err, content.ErrNoContentKind), + errors.Is(err, content.ErrNoStoragePolicy), + errors.Is(err, content.ErrInvalidRetention): + return http.StatusBadRequest + default: + return http.StatusInternalServerError + } +} + +func decodeJSON(w http.ResponseWriter, r *http.Request, destination any) error { + r.Body = http.MaxBytesReader(w, r.Body, maxJSONBody) + + decoder := json.NewDecoder(r.Body) + decoder.DisallowUnknownFields() + + if err := decoder.Decode(destination); err != nil { + if errors.Is(err, io.EOF) { + return errors.New("corps JSON requis") + } + return err + } + + var extra any + if err := decoder.Decode(&extra); !errors.Is(err, io.EOF) { + return errors.New("corps JSON invalide") + } + + return nil +} + +func metadataString(raw json.RawMessage) (string, error) { + if len(raw) == 0 { + return "{}", nil + } + if !json.Valid(raw) { + return "", fmt.Errorf("%w", document.ErrInvalidMetadata) + } + return string(raw), nil +} + +func idParam(r *http.Request, name string) (ident.UUID, error) { + value := r.PathValue(name) + if value == "" { + return ident.UUID{}, errors.New("identifiant manquant") + } + id, err := ident.Parse(value) + if err != nil { + return ident.UUID{}, fmt.Errorf("identifiant invalide: %w", err) + } + return id, nil +} diff --git a/cmd/server/cli.go b/cmd/server/cli.go index efd2cb7..421b636 100644 --- a/cmd/server/cli.go +++ b/cmd/server/cli.go @@ -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) }