forked from mtusi2026/mtusi2026lab4
165 lines
3.7 KiB
Go
165 lines
3.7 KiB
Go
package main
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"fmt"
|
|
"io"
|
|
"os"
|
|
"strconv"
|
|
"sync"
|
|
"time"
|
|
|
|
"messenger/internal/config"
|
|
"messenger/internal/repository/s3"
|
|
)
|
|
|
|
func main() {
|
|
if len(os.Args) < 2 {
|
|
usage()
|
|
}
|
|
if err := run(os.Args[1], os.Args[2:]); err != nil {
|
|
fmt.Fprintln(os.Stderr, "s3tool failed:", err)
|
|
os.Exit(1)
|
|
}
|
|
}
|
|
|
|
func run(command string, args []string) error {
|
|
store, err := newStore()
|
|
if err != nil {
|
|
return err
|
|
}
|
|
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
|
|
defer cancel()
|
|
|
|
switch command {
|
|
case "put":
|
|
if len(args) != 2 {
|
|
usage()
|
|
}
|
|
content, err := readContent(args[1])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if err := store.Put(ctx, args[0], bytes.NewReader(content), int64(len(content)), "application/octet-stream"); err != nil {
|
|
return err
|
|
}
|
|
fmt.Printf("put %s (%d bytes)\n", args[0], len(content))
|
|
case "delete":
|
|
if len(args) != 1 {
|
|
usage()
|
|
}
|
|
if err := store.Delete(ctx, args[0]); err != nil {
|
|
return err
|
|
}
|
|
fmt.Printf("deleted %s\n", args[0])
|
|
case "list":
|
|
prefix := ""
|
|
if len(args) > 0 {
|
|
prefix = args[0]
|
|
}
|
|
objects, _, err := store.List(ctx, prefix, 1000)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, object := range objects {
|
|
fmt.Printf("%s\t%d\t%s\n", object.Key, object.Size, object.LastModified.UTC().Format(time.RFC3339))
|
|
}
|
|
case "buckets":
|
|
buckets, err := store.Buckets(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, bucket := range buckets {
|
|
fmt.Println(bucket)
|
|
}
|
|
case "remove-bucket":
|
|
if len(args) != 1 {
|
|
usage()
|
|
}
|
|
if err := store.RemoveBucket(ctx, args[0]); err != nil {
|
|
return err
|
|
}
|
|
fmt.Printf("removed %s\n", args[0])
|
|
case "seed":
|
|
if len(args) != 3 {
|
|
usage()
|
|
}
|
|
count, err := strconv.Atoi(args[1])
|
|
if err != nil || count <= 0 {
|
|
return fmt.Errorf("count must be a positive integer")
|
|
}
|
|
size, err := strconv.Atoi(args[2])
|
|
if err != nil || size <= 0 {
|
|
return fmt.Errorf("size must be a positive integer")
|
|
}
|
|
if err := seed(ctx, store, args[0], count, size); err != nil {
|
|
return err
|
|
}
|
|
fmt.Printf("seeded %d objects under %s\n", count, args[0])
|
|
default:
|
|
usage()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func readContent(source string) ([]byte, error) {
|
|
if source == "-" {
|
|
return io.ReadAll(os.Stdin)
|
|
}
|
|
return os.ReadFile(source)
|
|
}
|
|
|
|
func newStore() (*s3.Store, error) {
|
|
accessKeyID, err := config.ReadSecret("S3_ACCESS_KEY_ID_FILE", "/run/secrets/s3_access_key_id")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
secretAccessKey, err := config.ReadSecret("S3_SECRET_ACCESS_KEY_FILE", "/run/secrets/s3_secret_access_key")
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return s3.New(getenv("S3_ENDPOINT", "http://s3:9000"), getenv("S3_REGION", "us-east-1"),
|
|
accessKeyID, secretAccessKey, getenv("S3_BUCKET", "messenger-attachments"))
|
|
}
|
|
|
|
func seed(ctx context.Context, store *s3.Store, prefix string, count, size int) error {
|
|
content := make([]byte, size)
|
|
workers := 8
|
|
work := make(chan int)
|
|
errors := make(chan error, workers)
|
|
var group sync.WaitGroup
|
|
for i := 0; i < workers; i++ {
|
|
group.Add(1)
|
|
go func() {
|
|
defer group.Done()
|
|
for index := range work {
|
|
key := fmt.Sprintf("%s/%06d", prefix, index)
|
|
if err := store.Put(ctx, key, bytes.NewReader(content), int64(size), "application/octet-stream"); err != nil {
|
|
errors <- err
|
|
return
|
|
}
|
|
}
|
|
}()
|
|
}
|
|
for index := 0; index < count; index++ {
|
|
work <- index
|
|
}
|
|
close(work)
|
|
group.Wait()
|
|
close(errors)
|
|
return <-errors
|
|
}
|
|
|
|
func usage() {
|
|
fmt.Fprintln(os.Stderr, "usage: s3tool put <key> <file> | delete <key> | list [prefix] | buckets | remove-bucket <name> | seed <prefix> <count> <bytes>")
|
|
os.Exit(2)
|
|
}
|
|
|
|
func getenv(key, def string) string {
|
|
if value := os.Getenv(key); value != "" {
|
|
return value
|
|
}
|
|
return def
|
|
}
|