Разделите настройки команд worker и сохраняйте причину сбоя

This commit is contained in:
2026-11-20 10:54:34 +03:00
parent 42a9bf2071
commit 8f90c78b98
8 changed files with 303 additions and 141 deletions
+104 -66
View File
@@ -5,11 +5,9 @@ import (
"context"
"encoding/json"
"errors"
"log/slog"
"os"
"os/signal"
"strconv"
"strings"
"syscall"
@@ -37,61 +35,110 @@ func main() {
}
}
const usage = "use failed, replay <id> <operator>, reprocess <id> <version>, or duplicate <id> <version> <attempt>"
type command struct {
name, actor, barrierDir string
id uuid.UUID
version, attempt int
}
func parseCommand(args []string) (command, error) {
var c command
if len(args) == 0 {
return c, nil
}
if dir, ok := strings.CutPrefix(args[0], "--barriers="); ok && len(args) == 1 && dir != "" {
c.barrierDir = dir
return c, nil
}
c.name = args[0]
switch c.name {
case "--prepare-large-png", "failed":
if len(args) == 1 {
return c, nil
}
return c, errors.New(usage)
case "replay", "reprocess":
if len(args) != 3 {
return c, errors.New(usage)
}
case "duplicate":
if len(args) != 4 {
return c, errors.New(usage)
}
default:
return c, errors.New(usage)
}
var err error
c.id, err = uuid.Parse(args[1])
if err != nil {
return c, errors.New("invalid attachment UUID")
}
if c.name == "replay" {
c.actor = strings.TrimSpace(args[2])
if c.actor == "" || len(c.actor) > 128 {
return c, errors.New("replay requires an operator name of up to 128 bytes")
}
return c, nil
}
c.version, err = strconv.Atoi(args[2])
if err != nil || c.version < 1 {
return c, errors.New("invalid pipeline version")
}
if c.name == "duplicate" {
c.attempt, err = strconv.Atoi(args[3])
if err != nil || c.attempt < 1 {
return c, errors.New("invalid attempt number")
}
}
return c, nil
}
func run(ctx context.Context, args []string) error {
if len(args) == 1 && args[0] == "--prepare-large-png" {
cmd, err := parseCommand(args)
if err != nil {
return err
}
if cmd.name == "--prepare-large-png" {
return imaging.PrepareLargePNG(os.Stdin)
}
if cmd.name != "" {
var cancel context.CancelFunc
ctx, cancel = context.WithTimeout(ctx, 15*time.Second)
defer cancel()
}
db, err := config.LoadDatabaseURL(os.LookupEnv)
if err != nil {
return err
}
cfg, err := config.LoadJobs(os.LookupEnv)
if err != nil {
return err
}
s3, err := config.LoadS3(os.LookupEnv)
if err != nil {
return err
}
blobs, err := s3store.New(s3)
if err != nil {
return err
}
pool, err := postgres.NewPool(ctx, db, 5)
if err != nil {
return err
}
defer pool.Close()
store := pipeline.NewStore(pool)
w := processing.Worker{Store: store, Blobs: blobs, Config: cfg, Log: slog.Default()}
if len(args) == 1 && strings.HasPrefix(args[0], "--barriers=") {
dir := strings.TrimPrefix(args[0], "--barriers=")
if err := os.MkdirAll(dir, 0700); err != nil {
return err
}
w.Checkpoint = processing.FileBarrier(dir)
args = nil
}
if len(args) == 0 {
w.Run(ctx)
return nil
}
op, cancel := context.WithTimeout(ctx, 15*time.Second)
defer cancel()
if len(args) == 1 && args[0] == "failed" {
jobs, err := store.Failed(op)
switch cmd.name {
case "failed":
jobs, err := store.Failed(ctx)
if err != nil {
return err
}
return json.NewEncoder(os.Stdout).Encode(jobs)
case "duplicate":
url, err := config.LoadBrokerURL(os.LookupEnv)
if err != nil {
return err
}
return duplicate(ctx, pool, url, cmd.id, cmd.version, cmd.attempt)
}
const usage = "use failed, replay <id> <operator>, reprocess <id> <version>, or duplicate <id> <version> <attempt>"
if len(args) < 3 {
return errors.New(usage)
}
id, err := uuid.Parse(args[1])
s3, err := config.LoadS3(os.LookupEnv)
if err != nil {
return errors.New("invalid attachment UUID")
return err
}
blobs, err := s3store.New(s3)
if err != nil {
return err
}
exists := func(ctx context.Context, key string) (bool, error) {
_, err := blobs.Stat(ctx, key)
@@ -100,37 +147,28 @@ func run(ctx context.Context, args []string) error {
}
return err == nil, err
}
switch args[0] {
switch cmd.name {
case "replay":
if len(args) != 3 {
return errors.New(usage)
}
return store.Replay(op, id, args[2], exists)
return store.Replay(ctx, cmd.id, cmd.actor, exists)
case "reprocess":
if len(args) != 3 {
return errors.New(usage)
}
v, err := strconv.Atoi(args[2])
if err != nil {
return err
}
return store.Reprocess(op, id, v, exists)
case "duplicate":
if len(args) != 4 {
return errors.New(usage)
}
version, err := strconv.Atoi(args[2])
if err != nil {
return err
}
attempt, err := strconv.Atoi(args[3])
if err != nil {
return err
}
return duplicate(op, pool, cfg.URL, id, version, attempt)
default:
return errors.New(usage)
return store.Reprocess(ctx, cmd.id, cmd.version, exists)
}
cfg, err := config.LoadJobs(os.LookupEnv)
if err != nil {
return err
}
w := processing.Worker{Store: store, Blobs: blobs, Config: cfg, Log: slog.Default()}
if cmd.barrierDir != "" {
if err := os.MkdirAll(cmd.barrierDir, 0700); err != nil {
return err
}
w.Checkpoint = processing.FileBarrier(cmd.barrierDir)
}
if err := imaging.CleanScratch(); err != nil {
return err
}
w.Run(ctx)
return nil
}
// duplicate sends a previously issued envelope through the actual broker. It
+39
View File
@@ -0,0 +1,39 @@
package main
import (
"os"
"path/filepath"
"strings"
"testing"
"messenger/internal/testenv"
)
func TestInvalidCommandBeforeConfig(t *testing.T) {
t.Setenv("DATABASE_URL_FILE", "")
for _, args := range [][]string{{"unknown"}, {"replay", "bad-id", "admin"}, {"duplicate", "00000000-0000-4000-8000-000000000001", "1", "invalid"}} {
err := run(t.Context(), args)
if err == nil || strings.Contains(err.Error(), "DATABASE_URL") {
t.Errorf("run(%q) must report argument error, got %v", args, err)
}
}
}
func TestFailedNeedsOnlyPostgres(t *testing.T) {
db, err := testenv.StartPostgres(t.Context())
if err != nil {
t.Fatal(err)
}
defer db.Close()
path := filepath.Join(t.TempDir(), "dsn")
if err := os.WriteFile(path, []byte(db.DSN), 0600); err != nil {
t.Fatal(err)
}
t.Setenv("DATABASE_URL_FILE", path)
t.Setenv("BROKER_URL_FILE", "missing-broker")
t.Setenv("S3_ENDPOINT", "invalid")
t.Setenv("S3_SECRET_ACCESS_KEY_FILE", "")
if err := run(t.Context(), []string{"failed"}); err != nil {
t.Fatal(err)
}
}