115 lines
3.8 KiB
Go
115 lines
3.8 KiB
Go
package orbit
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"reflect"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestIntegrationWorkerRuntimePriority(t *testing.T) {
|
|
api, _, _ := integrationWorkerClient(t)
|
|
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
|
|
defer cancel()
|
|
name := "priority." + workerTestID(t)
|
|
q, err := api.CreateQueue(ctx, name, CreateQueueRequest{Name: name, MaxConcurrency: 1, RatePerSecond: 100})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
base := map[string]any{"queue_id": q.Queue.ID, "handler": name, "handler_version": "v1", "payload_version": "v1", "payload": map[string]any{}}
|
|
for _, invalid := range []any{-1, 10, 1.5, nil, "9", true} {
|
|
base["priority"] = invalid
|
|
var ignored SubmitTaskResult
|
|
err := api.call(ctx, "POST", "/v1/tasks", workerTestID(t), base, &ignored)
|
|
var rejected *APIError
|
|
if !errors.As(err, &rejected) || rejected.StatusCode != 400 {
|
|
t.Fatalf("invalid priority %v accepted: %v", invalid, err)
|
|
}
|
|
}
|
|
var tasks []Task
|
|
for _, priority := range []int16{0, 9, 4} {
|
|
out, err := api.SubmitTask(ctx, workerTestID(t), SubmitTaskRequest{QueueID: q.Queue.ID, Handler: name, HandlerVersion: "v1", PayloadVersion: "v1", Payload: json.RawMessage(`{"n":9007199254740993}`), Priority: priority})
|
|
if err != nil || out.Task.Priority != priority {
|
|
t.Fatal("priority not accepted", err)
|
|
}
|
|
tasks = append(tasks, out.Task)
|
|
}
|
|
observed := make(chan int16, 3)
|
|
w, err := NewWorker(api, WorkerOptions{QueueID: q.Queue.ID, Capacity: 1, Handlers: []WorkerHandler{runtimeHandler(name, func(ctx context.Context, e WorkerExecution) (json.RawMessage, error) {
|
|
observed <- e.Task.Priority
|
|
return e.Task.Payload, nil
|
|
})}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
run, stop := context.WithCancel(ctx)
|
|
done := make(chan error, 1)
|
|
go func() { done <- w.Run(run) }()
|
|
defer func() {
|
|
stop()
|
|
if err := <-done; err != nil {
|
|
t.Error(err)
|
|
}
|
|
}()
|
|
for _, task := range tasks {
|
|
v := waitRuntimeState(t, ctx, api, task.ID, TaskSucceeded)
|
|
if v.Priority != task.Priority {
|
|
t.Fatal("priority changed")
|
|
}
|
|
}
|
|
got := []int16{<-observed, <-observed, <-observed}
|
|
if !reflect.DeepEqual(got, []int16{9, 4, 0}) {
|
|
t.Fatalf("dispatch priorities %v", got)
|
|
}
|
|
}
|
|
|
|
func TestIntegrationWorkerProcessPriorityRecovery(t *testing.T) {
|
|
a := startOrbitProcess(t)
|
|
_, _, token := integrationWorkerClient(t)
|
|
api := processClient(t, a, token)
|
|
ctx, cancel := context.WithTimeout(context.Background(), 20*time.Second)
|
|
defer cancel()
|
|
name := "priority-crash." + workerTestID(t)
|
|
q, err := api.CreateQueue(ctx, name, CreateQueueRequest{Name: name, MaxConcurrency: 1, RatePerSecond: 100})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, p := range []int16{0, 9, 4} {
|
|
if _, err := api.SubmitTask(ctx, workerTestID(t), SubmitTaskRequest{QueueID: q.Queue.ID, Handler: name, HandlerVersion: "v1", PayloadVersion: "v1", Payload: json.RawMessage(`{}`), Priority: p}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
a.kill(t)
|
|
b := startOrbitProcess(t)
|
|
if a.nodeID == b.nodeID {
|
|
t.Fatal("node id reused")
|
|
}
|
|
api = processClient(t, b, token)
|
|
r, err := NewWorkerRegistration(q.Queue.ID, 1, []WorkerCapability{{Handler: name, HandlerVersion: "v1", PayloadVersion: "v1"}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
w, err := api.DialWorker(ctx, r)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer w.Close()
|
|
if _, err = w.Capacity(ctx, workerTestID(t), WorkerCapacity{Sequence: 1, Capacity: 1}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, want := range []int16{9, 4, 0} {
|
|
a, err := w.NextAssignment(ctx)
|
|
if err != nil || a.Task.Priority != want {
|
|
t.Fatal("restart lost frozen dispatch order", err)
|
|
}
|
|
if _, err = w.Start(ctx, workerTestID(t), a.Attempt()); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err = w.Finish(ctx, workerTestID(t), WorkerFinish{Ref: a.Attempt(), Outcome: WorkerSucceeded, Result: json.RawMessage(`{}`)}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
}
|