Files
mtusi2026lab6/service/cmd/app/storage.go
T
2026-11-17 13:08:13 +03:00

184 lines
6.0 KiB
Go

package main
import (
"context"
"encoding/json"
"errors"
"flag"
"fmt"
"log/slog"
"net/http"
"os"
"strings"
"time"
"github.com/aws/aws-sdk-go-v2/service/s3"
"github.com/aws/smithy-go"
"github.com/google/uuid"
"gitea.privcloud.tech/mtusi2026/internal/adapter/repository/storage"
"gitea.privcloud.tech/mtusi2026/internal/config"
"gitea.privcloud.tech/mtusi2026/internal/pkg/objectstore"
"gitea.privcloud.tech/mtusi2026/internal/pkg/postgres"
"gitea.privcloud.tech/mtusi2026/internal/pkg/postgres/txmanager"
"gitea.privcloud.tech/mtusi2026/internal/service/attachment"
"gitea.privcloud.tech/mtusi2026/internal/service/outbox"
)
func runStorage(cfg *config.Config, c *config.Attachment, args []string) error {
slog.SetDefault(slog.New(slog.NewJSONHandler(os.Stderr, &slog.HandlerOptions{Level: slog.LevelWarn})))
if len(args) == 0 {
return fmt.Errorf("storage command required")
}
ctx, cancel := context.WithTimeout(context.Background(), 10*time.Minute)
defer cancel()
store := objectstore.New(c)
if args[0] == "bootstrap" {
var err error
for i := 0; i < 60; i++ {
_, err = store.Client.CreateBucket(ctx, &s3.CreateBucketInput{Bucket: &c.Bucket})
var api smithy.APIError
if err == nil || (errors.As(err, &api) && (api.ErrorCode() == "BucketAlreadyOwnedByYou" || api.ErrorCode() == "BucketAlreadyExists")) {
if store.Ping(ctx) == nil {
// HEAD alone can succeed before the restarted master/volume write path.
// This constant key is outside the application's immutable originals prefix.
key := "bootstrap/write-check"
if store.Put(ctx, key, "application/octet-stream", strings.NewReader("ready"), 5) == nil && store.Delete(ctx, key) == nil {
return json.NewEncoder(os.Stdout).Encode(map[string]any{"bucket_ready": true, "write_checked": true})
}
}
}
time.Sleep(time.Second)
}
return fmt.Errorf("storage bootstrap failed: %w", err)
}
if args[0] == "private-check" {
// Unsigned requests must reach the S3 server and receive an auth failure,
// rather than passing because a network error hid a public object.
fs := flag.NewFlagSet("private-check", flag.ContinueOnError)
key := fs.String("key", "", "known object key")
if e := fs.Parse(args[1:]); e != nil {
return e
}
client := http.Client{Timeout: 5 * time.Second, CheckRedirect: func(*http.Request, []*http.Request) error { return http.ErrUseLastResponse }}
resp, e := client.Get(c.Endpoint + "/" + c.Bucket + "/" + *key)
if e != nil {
return e
}
defer resp.Body.Close()
if resp.StatusCode != 401 && resp.StatusCode != 403 {
return fmt.Errorf("unsigned GET returned %d", resp.StatusCode)
}
_, e = store.Client.CreateBucket(ctx, &s3.CreateBucketInput{Bucket: new("forbidden-" + uuid.NewString())})
var api smithy.APIError
if !errors.As(e, &api) || api.ErrorCode() != "AccessDenied" {
return fmt.Errorf("API key bucket creation was not denied")
}
return json.NewEncoder(os.Stdout).Encode(map[string]any{"anonymous_status": resp.StatusCode, "api_create_bucket_denied": true})
}
if args[0] == "object-check" {
fs := flag.NewFlagSet("object-check", flag.ContinueOnError)
key := fs.String("key", "", "synthetic object key")
if e := fs.Parse(args[1:]); e != nil {
return e
}
head, e := store.Head(ctx, *key)
if objectstore.Missing(e) {
return json.NewEncoder(os.Stdout).Encode(map[string]any{"exists": false})
}
if e != nil {
return e
}
return json.NewEncoder(os.Stdout).Encode(map[string]any{"exists": true, "last_modified": head.LastModified, "size_bytes": head.ContentLength})
}
pool := postgres.New(cfg.Postgres)
defer pool.Close()
svc := attachment.New(&storage.AttachmentsRepo{Pool: pool}, store, c, nil)
jobs, e := config.LoadPipeline()
if e != nil {
return e
}
tm := txmanager.New(pool)
svc.Configure(tm, outbox.New(&storage.OutboxRepo{Pool: pool}, tm, nil), jobs)
switch args[0] {
case "reconcile":
fs := flag.NewFlagSet("reconcile", flag.ContinueOnError)
apply := fs.Bool("apply", false, "apply safe changes")
if e := fs.Parse(args[1:]); e != nil {
return e
}
result, e := svc.Reconcile(ctx, *apply)
_ = json.NewEncoder(os.Stdout).Encode(result)
return e
case "restore":
fs := flag.NewFlagSet("restore", flag.ContinueOnError)
id := fs.String("id", "", "attachment id")
source := fs.String("source", "", "original file")
if e := fs.Parse(args[1:]); e != nil {
return e
}
uid, e := uuid.Parse(*id)
if e != nil {
return e
}
if e = svc.Restore(ctx, uid, *source); e != nil {
return e
}
return json.NewEncoder(os.Stdout).Encode(map[string]any{"restored": uid})
case "seed":
fs := flag.NewFlagSet("seed", flag.ContinueOnError)
count := fs.Int("count", 1, "synthetic orphan count")
keyOverride := fs.String("key", "", "explicit key for a single synthetic object")
if e := fs.Parse(args[1:]); e != nil {
return e
}
if *count < 1 || *count > 10000 {
return fmt.Errorf("count must be 1..10000")
}
keys := []string{}
for i := 0; i < *count; i++ {
key := attachment.Prefix + uuid.NewString()
if *keyOverride != "" {
if *count != 1 {
return fmt.Errorf("explicit key requires count=1")
}
key = *keyOverride
}
if e := store.Put(ctx, key, "image/png", strings.NewReader("synthetic-orphan"), 16); e != nil {
return e
}
if *count == 1 {
keys = append(keys, key)
}
}
return json.NewEncoder(os.Stdout).Encode(map[string]any{"seeded": *count, "keys": keys})
case "remove-object":
fs := flag.NewFlagSet("remove-object", flag.ContinueOnError)
id := fs.String("id", "", "synthetic attachment id")
if e := fs.Parse(args[1:]); e != nil {
return e
}
uid, e := uuid.Parse(*id)
if e != nil {
return e
}
a, e := svc.Repo.Get(ctx, uid)
if e != nil {
return e
}
conn, unlock, e := svc.Repo.Lock(ctx, a.Key)
_ = conn
if e != nil {
return e
}
defer unlock()
if e = store.Delete(ctx, a.Key); e != nil {
return e
}
return json.NewEncoder(os.Stdout).Encode(map[string]any{"removed_object": uid})
default:
return fmt.Errorf("unknown storage command")
}
}