forked from mtusi2026/mtusi2026lab6
184 lines
6.0 KiB
Go
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")
|
|
}
|
|
}
|