From db97c5ea13d10fc45879bdfc0099e8603ccc998e Mon Sep 17 00:00:00 2001 From: Haven Xia Date: Fri, 26 Jun 2026 16:12:20 -0700 Subject: [PATCH] Fold actor name+atespace into ActorRef across actor RPCs An actor name is only unique within its atespace, so the two always travel together. Add ActorRef{atespace, name} and use it across the Get/Create/Update/Suspend/Pause/Resume/Delete actor requests in place of separate actor_id + atespace fields. The stored Actor object and Redis key layout are unchanged. --- .../internal/controlapi/create_actor.go | 18 +- .../internal/controlapi/delete_actor.go | 16 +- .../internal/controlapi/functional_test.go | 264 +++----- cmd/ateapi/internal/controlapi/get_actor.go | 8 +- cmd/ateapi/internal/controlapi/pause_actor.go | 8 +- .../internal/controlapi/resume_actor.go | 8 +- .../internal/controlapi/suspend_actor.go | 8 +- .../internal/controlapi/update_actor.go | 10 +- .../controllers/actortemplate_controller.go | 9 +- cmd/atenet/internal/router/extproc_test.go | 4 +- cmd/atenet/internal/router/resumer.go | 3 +- cmd/kubectl-ate/internal/cmd/create_actor.go | 3 +- cmd/kubectl-ate/internal/cmd/delete_actor.go | 3 +- cmd/kubectl-ate/internal/cmd/get_actors.go | 2 +- cmd/kubectl-ate/internal/cmd/logs_actors.go | 6 +- .../internal/cmd/logs_actors_test.go | 4 +- cmd/kubectl-ate/internal/cmd/pause_actor.go | 3 +- cmd/kubectl-ate/internal/cmd/resume_actor.go | 3 +- cmd/kubectl-ate/internal/cmd/suspend_actor.go | 3 +- demos/agent-secret/main.go | 2 +- demos/sandbox/client/main.go | 4 +- internal/e2e/suites/demo/demo_test.go | 74 +-- internal/e2e/suites/identity/identity_test.go | 9 +- pkg/proto/ateapipb/ateapi.pb.go | 617 +++++++++--------- pkg/proto/ateapipb/ateapi.proto | 33 +- 25 files changed, 520 insertions(+), 602 deletions(-) diff --git a/cmd/ateapi/internal/controlapi/create_actor.go b/cmd/ateapi/internal/controlapi/create_actor.go index f9daa24f1..697250e05 100644 --- a/cmd/ateapi/internal/controlapi/create_actor.go +++ b/cmd/ateapi/internal/controlapi/create_actor.go @@ -42,15 +42,15 @@ func (s *Service) CreateActor(ctx context.Context, req *ateapipb.CreateActorRequ } // The atespace must already exist. - exists, err := s.persistence.AtespaceExists(ctx, req.GetAtespace()) + exists, err := s.persistence.AtespaceExists(ctx, req.GetActorRef().GetAtespace()) if err != nil { return nil, fmt.Errorf("while checking atespace: %w", err) } if !exists { - return nil, status.Errorf(codes.FailedPrecondition, "Atespace %s not found", req.GetAtespace()) + return nil, status.Errorf(codes.FailedPrecondition, "Atespace %s not found", req.GetActorRef().GetAtespace()) } - id := req.GetActorId() + id := req.GetActorRef().GetName() actor := &ateapipb.Actor{ ActorId: id, Version: 1, @@ -58,7 +58,7 @@ func (s *Service) CreateActor(ctx context.Context, req *ateapipb.CreateActorRequ ActorTemplateNamespace: req.GetActorTemplateNamespace(), ActorTemplateName: req.GetActorTemplateName(), WorkerSelector: req.GetWorkerSelector(), - Atespace: req.GetAtespace(), + Atespace: req.GetActorRef().GetAtespace(), } err = s.persistence.CreateActor(ctx, actor) if err != nil { @@ -68,7 +68,7 @@ func (s *Service) CreateActor(ctx context.Context, req *ateapipb.CreateActorRequ return nil, fmt.Errorf("while recording actor: %w", err) } - storedActor, err := s.persistence.GetActor(ctx, req.GetAtespace(), id) + storedActor, err := s.persistence.GetActor(ctx, req.GetActorRef().GetAtespace(), id) if err != nil { return nil, fmt.Errorf("while fetching recorded actor from DB: %w", err) } @@ -85,16 +85,16 @@ func validateCreateActorRequest(req *ateapipb.CreateActorRequest) error { if req.GetActorTemplateName() == "" { return status.Error(codes.InvalidArgument, "actor_template_name is required") } - if req.GetActorId() == "" { + if req.GetActorRef().GetName() == "" { return status.Error(codes.InvalidArgument, "actor_id is required") } - if err := resources.ValidateActorID(req.GetActorId()); err != nil { + if err := resources.ValidateActorID(req.GetActorRef().GetName()); err != nil { return status.Error(codes.InvalidArgument, err.Error()) } - if req.GetAtespace() == "" { + if req.GetActorRef().GetAtespace() == "" { return status.Error(codes.InvalidArgument, "atespace is required") } - if err := resources.ValidateAtespace(req.GetAtespace()); err != nil { + if err := resources.ValidateAtespace(req.GetActorRef().GetAtespace()); err != nil { return status.Error(codes.InvalidArgument, err.Error()) } if err := validateSelector(req.GetWorkerSelector()); err != nil { diff --git a/cmd/ateapi/internal/controlapi/delete_actor.go b/cmd/ateapi/internal/controlapi/delete_actor.go index 45a6ee0ac..9a0802e8f 100644 --- a/cmd/ateapi/internal/controlapi/delete_actor.go +++ b/cmd/ateapi/internal/controlapi/delete_actor.go @@ -31,16 +31,16 @@ func (s *Service) DeleteActor(ctx context.Context, req *ateapipb.DeleteActorRequ return nil, err } - if err := s.persistence.DeleteActor(ctx, req.GetAtespace(), req.GetActorId()); err != nil { + if err := s.persistence.DeleteActor(ctx, req.GetActorRef().GetAtespace(), req.GetActorRef().GetName()); err != nil { if errors.Is(err, store.ErrNotFound) { - return nil, status.Errorf(codes.NotFound, "Actor %s not found", req.GetActorId()) + return nil, status.Errorf(codes.NotFound, "Actor %s not found", req.GetActorRef().GetName()) } if errors.Is(err, store.ErrFailedPrecondition) { - actor, getErr := s.persistence.GetActor(ctx, req.GetAtespace(), req.GetActorId()) + actor, getErr := s.persistence.GetActor(ctx, req.GetActorRef().GetAtespace(), req.GetActorRef().GetName()) if getErr == nil { - return nil, status.Errorf(codes.FailedPrecondition, "Actor %s is not suspended (status: %v)", req.GetActorId(), actor.GetStatus()) + return nil, status.Errorf(codes.FailedPrecondition, "Actor %s is not suspended (status: %v)", req.GetActorRef().GetName(), actor.GetStatus()) } - return nil, status.Errorf(codes.FailedPrecondition, "Actor %s is not suspended", req.GetActorId()) + return nil, status.Errorf(codes.FailedPrecondition, "Actor %s is not suspended", req.GetActorRef().GetName()) } if errors.Is(err, store.ErrPersistenceRetry) { return nil, status.Error(codes.Aborted, "concurrent update conflict, please retry") @@ -52,13 +52,13 @@ func (s *Service) DeleteActor(ctx context.Context, req *ateapipb.DeleteActorRequ } func validateDeleteActorRequest(req *ateapipb.DeleteActorRequest) error { - if req.GetActorId() == "" { + if req.GetActorRef().GetName() == "" { return status.Error(codes.InvalidArgument, "actor_id is required") } - if err := resources.ValidateActorID(req.GetActorId()); err != nil { + if err := resources.ValidateActorID(req.GetActorRef().GetName()); err != nil { return status.Error(codes.InvalidArgument, err.Error()) } - if req.GetAtespace() == "" { + if req.GetActorRef().GetAtespace() == "" { return status.Error(codes.InvalidArgument, "atespace is required") } return nil diff --git a/cmd/ateapi/internal/controlapi/functional_test.go b/cmd/ateapi/internal/controlapi/functional_test.go index 089cd43c3..4de8e4d0e 100644 --- a/cmd/ateapi/internal/controlapi/functional_test.go +++ b/cmd/ateapi/internal/controlapi/functional_test.go @@ -638,10 +638,9 @@ func TestCreateActor_Success(t *testing.T) { createTemplate(t, tc, ns) createResp, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ - Atespace: testAtespace, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: "id1", WorkerSelector: &ateapipb.Selector{MatchLabels: map[string]string{"tier": "free"}}, }) if err != nil { @@ -672,10 +671,9 @@ func TestCreateActor_TemplateNotFound(t *testing.T) { defer tc.cleanup() _, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ - Atespace: testAtespace, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, ActorTemplateNamespace: ns, ActorTemplateName: "non-existent", - ActorId: "id1", }) assertGrpcError(t, err, codes.FailedPrecondition, fmt.Sprintf("ActorTemplate %s/non-existent not found", ns)) } @@ -689,20 +687,18 @@ func TestCreateActor_Duplicate(t *testing.T) { createTemplate(t, tc, ns) _, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ - Atespace: testAtespace, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: "id1", }) if err != nil { t.Fatalf("first CreateActor failed: %v", err) } _, err = tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ - Atespace: testAtespace, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: "id1", }) assertGrpcError(t, err, codes.AlreadyExists, "Actor id1 already exists") } @@ -716,10 +712,9 @@ func TestGetActor_Found(t *testing.T) { createTemplate(t, tc, ns) createResp, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ - Atespace: testAtespace, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: "id1", }) if err != nil { t.Fatalf("CreateActor failed: %v", err) @@ -728,8 +723,7 @@ func TestGetActor_Found(t *testing.T) { id := createResp.GetActor().GetActorId() getResp, err := tc.client.GetActor(context.Background(), &ateapipb.GetActorRequest{ - Atespace: testAtespace, - ActorId: id, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}, }) if err != nil { t.Fatalf("GetActor failed: %v", err) @@ -754,8 +748,7 @@ func TestGetActor_NotFound(t *testing.T) { defer tc.cleanup() _, err := tc.client.GetActor(context.Background(), &ateapipb.GetActorRequest{ - Atespace: testAtespace, - ActorId: "non-existent", + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "non-existent"}, }) assertGrpcError(t, err, codes.NotFound, "Actor non-existent not found") } @@ -774,19 +767,17 @@ func TestListActors(t *testing.T) { createTemplate(t, tc, ns) resp1, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ - Atespace: testAtespace, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: "id1", }) if err != nil { t.Fatalf("CreateActor 1 failed: %v", err) } resp2, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ - Atespace: testAtespace, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id2"}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: "id2", }) if err != nil { t.Fatalf("CreateActor 2 failed: %v", err) @@ -832,10 +823,9 @@ func TestListActors_ByAtespace(t *testing.T) { create := func(id, atespace string) *ateapipb.Actor { resp, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ + ActorRef: &ateapipb.ActorRef{Atespace: atespace, Name: id}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: id, - Atespace: atespace, }) if err != nil { t.Fatalf("CreateActor(%s, atespace=%q) failed: %v", id, atespace, err) @@ -870,10 +860,10 @@ func TestListActors_ByAtespace(t *testing.T) { } // Get is scoped: the right atespace hits, the empty atespace misses (deny-across by key). - if _, err := tc.client.GetActor(context.Background(), &ateapipb.GetActorRequest{ActorId: "id1", Atespace: "team-a"}); err != nil { + if _, err := tc.client.GetActor(context.Background(), &ateapipb.GetActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: "team-a", Name: "id1"}}); err != nil { t.Errorf("GetActor(id1, team-a) failed: %v", err) } - _, err = tc.client.GetActor(context.Background(), &ateapipb.GetActorRequest{Atespace: testAtespace, ActorId: "id1"}) + _, err = tc.client.GetActor(context.Background(), &ateapipb.GetActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}}) assertGrpcError(t, err, codes.NotFound, "Actor id1 not found") } @@ -890,10 +880,9 @@ func TestListActors_AllAtespaces(t *testing.T) { create := func(id, atespace string) { if _, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ + ActorRef: &ateapipb.ActorRef{Atespace: atespace, Name: id}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: id, - Atespace: atespace, }); err != nil { t.Fatalf("CreateActor(%s, atespace=%q) failed: %v", id, atespace, err) } @@ -929,10 +918,9 @@ func TestListActors_Pagination(t *testing.T) { var want []*ateapipb.Actor for i := 0; i < 5; i++ { resp, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ - Atespace: testAtespace, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: fmt.Sprintf("id%d", i)}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: fmt.Sprintf("id%d", i), }) if err != nil { t.Fatalf("CreateActor %d failed: %v", i, err) @@ -1060,10 +1048,9 @@ func TestResumeActor(t *testing.T) { createWorkerPod(t, tc, ns, "worker-1", "node1", "pool1") _, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ - Atespace: testAtespace, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: "id1", }) if err != nil { t.Fatalf("CreateActor failed: %v", err) @@ -1071,8 +1058,7 @@ func TestResumeActor(t *testing.T) { id := "id1" _, err = tc.client.ResumeActor(context.Background(), &ateapipb.ResumeActorRequest{ - Atespace: testAtespace, - ActorId: id, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}, }) if err != nil { t.Fatalf("ResumeActor failed: %v", err) @@ -1083,8 +1069,7 @@ func TestResumeActor(t *testing.T) { } getResp, err := tc.client.GetActor(context.Background(), &ateapipb.GetActorRequest{ - Atespace: testAtespace, - ActorId: id, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}, }) if err != nil { t.Fatalf("GetActor failed: %v", err) @@ -1182,17 +1167,15 @@ func TestResumeActorResolvesValueFromEnv(t *testing.T) { createWorkerPod(t, tc, ns, "worker-1", "node1", "pool1") _, err = tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ - Atespace: testAtespace, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: "id1", }) if err != nil { t.Fatalf("CreateActor failed: %v", err) } _, err = tc.client.ResumeActor(context.Background(), &ateapipb.ResumeActorRequest{ - Atespace: testAtespace, - ActorId: "id1", + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, }) if err != nil { t.Fatalf("ResumeActor failed: %v", err) @@ -1238,10 +1221,9 @@ func TestResumeActor_NoWorkers(t *testing.T) { createTemplate(t, tc, ns) createResp, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ - Atespace: testAtespace, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: "id1", }) if err != nil { t.Fatalf("CreateActor failed: %v", err) @@ -1250,8 +1232,7 @@ func TestResumeActor_NoWorkers(t *testing.T) { id := createResp.GetActor().GetActorId() _, err = tc.client.ResumeActor(context.Background(), &ateapipb.ResumeActorRequest{ - Atespace: testAtespace, - ActorId: id, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}, }) assertGrpcError(t, err, codes.FailedPrecondition, "no free workers available") } @@ -1269,17 +1250,17 @@ func TestResumeActor_NoEligiblePool(t *testing.T) { MatchLabels: map[string]string{"nonexistent": ns}, }) - createResp, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{Atespace: testAtespace, + createResp, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: "id1", }) if err != nil { t.Fatalf("CreateActor failed: %v", err) } - _, err = tc.client.ResumeActor(context.Background(), &ateapipb.ResumeActorRequest{Atespace: testAtespace, - ActorId: createResp.GetActor().GetActorId(), + _, err = tc.client.ResumeActor(context.Background(), &ateapipb.ResumeActorRequest{ + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: createResp.GetActor().GetActorId()}, }) assertGrpcError(t, err, codes.FailedPrecondition, "no worker pool matches the template's sandboxClass and the template/actor selectors") } @@ -1301,10 +1282,10 @@ func TestResumeActor_MultiPoolSelector(t *testing.T) { createWorkerPod(t, tc, ns, "worker-a", "node1", "pool-a") createWorkerPod(t, tc, ns, "worker-b", "node1", "pool-b") - _, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{Atespace: testAtespace, + _, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: "id1", WorkerSelector: &ateapipb.Selector{ MatchLabels: map[string]string{"tier": "b"}, }, @@ -1313,12 +1294,12 @@ func TestResumeActor_MultiPoolSelector(t *testing.T) { t.Fatalf("CreateActor failed: %v", err) } - _, err = tc.client.ResumeActor(context.Background(), &ateapipb.ResumeActorRequest{Atespace: testAtespace, ActorId: "id1"}) + _, err = tc.client.ResumeActor(context.Background(), &ateapipb.ResumeActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}}) if err != nil { t.Fatalf("ResumeActor failed: %v", err) } - getResp, err := tc.client.GetActor(context.Background(), &ateapipb.GetActorRequest{Atespace: testAtespace, ActorId: "id1"}) + getResp, err := tc.client.GetActor(context.Background(), &ateapipb.GetActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}}) if err != nil { t.Fatalf("GetActor failed: %v", err) } @@ -1352,10 +1333,10 @@ func TestResumeActor_RequiresBothSelectorsToMatch(t *testing.T) { createWorkerPod(t, tc, ns, "worker-template-only", "node1", "pool-template-only") createWorkerPod(t, tc, ns, "worker-actor-only", "node1", "pool-actor-only") - _, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{Atespace: testAtespace, + _, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: "id1", WorkerSelector: &ateapipb.Selector{ MatchLabels: map[string]string{"tier": "b"}, }, @@ -1364,11 +1345,11 @@ func TestResumeActor_RequiresBothSelectorsToMatch(t *testing.T) { t.Fatalf("CreateActor failed: %v", err) } - if _, err := tc.client.ResumeActor(context.Background(), &ateapipb.ResumeActorRequest{Atespace: testAtespace, ActorId: "id1"}); err != nil { + if _, err := tc.client.ResumeActor(context.Background(), &ateapipb.ResumeActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}}); err != nil { t.Fatalf("ResumeActor failed: %v", err) } - getResp, err := tc.client.GetActor(context.Background(), &ateapipb.GetActorRequest{Atespace: testAtespace, ActorId: "id1"}) + getResp, err := tc.client.GetActor(context.Background(), &ateapipb.GetActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}}) if err != nil { t.Fatalf("GetActor failed: %v", err) } @@ -1398,10 +1379,9 @@ func TestResumeActor_Reentrancy(t *testing.T) { createWorkerPod(t, tc, ns, "worker-1", "node1", "pool1") _, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ - Atespace: testAtespace, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: "id1", }) if err != nil { t.Fatalf("CreateActor failed: %v", err) @@ -1412,8 +1392,7 @@ func TestResumeActor_Reentrancy(t *testing.T) { tc.fakeAtelet.FailRestore = fmt.Errorf("mock atelet failure") _, err = tc.client.ResumeActor(context.Background(), &ateapipb.ResumeActorRequest{ - Atespace: testAtespace, - ActorId: id, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}, }) if err == nil { t.Fatalf("expected ResumeActor to fail due to atelet error") @@ -1433,8 +1412,7 @@ func TestResumeActor_Reentrancy(t *testing.T) { tc.fakeAtelet.RestoreCalled = false // reset for verification _, err = tc.client.ResumeActor(context.Background(), &ateapipb.ResumeActorRequest{ - Atespace: testAtespace, - ActorId: id, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}, }) if err != nil { t.Fatalf("ResumeActor failed on retry: %v", err) @@ -1474,10 +1452,9 @@ func TestSuspendActor(t *testing.T) { createWorkerPod(t, tc, ns, "worker-1", "node1", "pool1") _, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ - Atespace: testAtespace, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: "id1", }) if err != nil { t.Fatalf("CreateActor failed: %v", err) @@ -1486,8 +1463,7 @@ func TestSuspendActor(t *testing.T) { // Resume first to make it running _, err = tc.client.ResumeActor(context.Background(), &ateapipb.ResumeActorRequest{ - Atespace: testAtespace, - ActorId: id, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}, }) if err != nil { t.Fatalf("ResumeActor failed: %v", err) @@ -1495,8 +1471,7 @@ func TestSuspendActor(t *testing.T) { // Suspend _, err = tc.client.SuspendActor(context.Background(), &ateapipb.SuspendActorRequest{ - Atespace: testAtespace, - ActorId: id, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}, }) if err != nil { t.Fatalf("SuspendActor failed: %v", err) @@ -1507,8 +1482,7 @@ func TestSuspendActor(t *testing.T) { } getResp, err := tc.client.GetActor(context.Background(), &ateapipb.GetActorRequest{ - Atespace: testAtespace, - ActorId: id, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}, }) if err != nil { t.Fatalf("GetActor failed: %v", err) @@ -1563,10 +1537,9 @@ func TestPauseActor(t *testing.T) { createWorkerPod(t, tc, ns, "worker-1", "node1", "pool1") _, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ - Atespace: testAtespace, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: "id1", }) if err != nil { t.Fatalf("CreateActor failed: %v", err) @@ -1575,8 +1548,7 @@ func TestPauseActor(t *testing.T) { // Resume first to make it running _, err = tc.client.ResumeActor(context.Background(), &ateapipb.ResumeActorRequest{ - Atespace: testAtespace, - ActorId: id, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}, }) if err != nil { t.Fatalf("ResumeActor failed: %v", err) @@ -1584,8 +1556,7 @@ func TestPauseActor(t *testing.T) { // Pause _, err = tc.client.PauseActor(context.Background(), &ateapipb.PauseActorRequest{ - Atespace: testAtespace, - ActorId: id, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}, }) if err != nil { t.Fatalf("PauseActor failed: %v", err) @@ -1596,8 +1567,7 @@ func TestPauseActor(t *testing.T) { } getResp, err := tc.client.GetActor(context.Background(), &ateapipb.GetActorRequest{ - Atespace: testAtespace, - ActorId: id, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}, }) if err != nil { t.Fatalf("GetActor failed: %v", err) @@ -1642,10 +1612,10 @@ func TestUpdateActor_Success(t *testing.T) { createTemplate(t, tc, ns) - _, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{Atespace: testAtespace, + _, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: "id1", WorkerSelector: &ateapipb.Selector{ MatchLabels: map[string]string{"tier": "free"}, }, @@ -1654,8 +1624,8 @@ func TestUpdateActor_Success(t *testing.T) { t.Fatalf("CreateActor failed: %v", err) } - updateResp, err := tc.client.UpdateActor(context.Background(), &ateapipb.UpdateActorRequest{Atespace: testAtespace, - ActorId: "id1", + updateResp, err := tc.client.UpdateActor(context.Background(), &ateapipb.UpdateActorRequest{ + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, WorkerSelector: &ateapipb.Selector{ MatchLabels: map[string]string{"tier": "paid"}, }, @@ -1680,7 +1650,7 @@ func TestUpdateActor_Success(t *testing.T) { t.Errorf("UpdateActor response mismatch (-want +got):\n%s", diff) } - getResp, err := tc.client.GetActor(context.Background(), &ateapipb.GetActorRequest{Atespace: testAtespace, ActorId: "id1"}) + getResp, err := tc.client.GetActor(context.Background(), &ateapipb.GetActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}}) if err != nil { t.Fatalf("GetActor failed: %v", err) } @@ -1695,7 +1665,7 @@ func TestUpdateActor_NotFound(t *testing.T) { tc := setupTest(t, ns) defer tc.cleanup() - _, err := tc.client.UpdateActor(context.Background(), &ateapipb.UpdateActorRequest{Atespace: testAtespace, ActorId: "does-not-exist"}) + _, err := tc.client.UpdateActor(context.Background(), &ateapipb.UpdateActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "does-not-exist"}}) assertGrpcError(t, err, codes.NotFound, "Actor does-not-exist not found") } @@ -1727,10 +1697,10 @@ func TestResumeActor_ReleasesStaleWorkerWhenPoolBecomesIneligible(t *testing.T) createWorkerPod(t, tc, ns, "worker-b", "node1", "pool-b") id := "id1" - _, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{Atespace: testAtespace, + _, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: id, WorkerSelector: &ateapipb.Selector{MatchLabels: map[string]string{"tier": "a"}}, }) if err != nil { @@ -1738,24 +1708,24 @@ func TestResumeActor_ReleasesStaleWorkerWhenPoolBecomesIneligible(t *testing.T) } tc.fakeAtelet.FailRun = fmt.Errorf("mock atelet failure") - _, err = tc.client.ResumeActor(context.Background(), &ateapipb.ResumeActorRequest{Atespace: testAtespace, ActorId: id}) + _, err = tc.client.ResumeActor(context.Background(), &ateapipb.ResumeActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}}) if err == nil { t.Fatalf("expected first ResumeActor (onto worker-a) to fail") } tc.fakeAtelet.FailRun = nil - if _, err := tc.client.UpdateActor(context.Background(), &ateapipb.UpdateActorRequest{Atespace: testAtespace, - ActorId: id, + if _, err := tc.client.UpdateActor(context.Background(), &ateapipb.UpdateActorRequest{ + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}, WorkerSelector: &ateapipb.Selector{MatchLabels: map[string]string{"tier": "b"}}, }); err != nil { t.Fatalf("UpdateActor failed: %v", err) } - if _, err := tc.client.ResumeActor(context.Background(), &ateapipb.ResumeActorRequest{Atespace: testAtespace, ActorId: id}); err != nil { + if _, err := tc.client.ResumeActor(context.Background(), &ateapipb.ResumeActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}}); err != nil { t.Fatalf("second ResumeActor failed: %v", err) } - getResp, err := tc.client.GetActor(context.Background(), &ateapipb.GetActorRequest{Atespace: testAtespace, ActorId: id}) + getResp, err := tc.client.GetActor(context.Background(), &ateapipb.GetActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}}) if err != nil { t.Fatalf("GetActor failed: %v", err) } @@ -1815,10 +1785,10 @@ func TestUpdateActor_ReassignsPoolAcrossSuspendResume(t *testing.T) { createWorkerPod(t, tc, ns, "worker-b", "node1", "pool-b") id := "id1" - _, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{Atespace: testAtespace, + _, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: id, WorkerSelector: &ateapipb.Selector{ MatchLabels: map[string]string{"tier": "a"}, }, @@ -1827,11 +1797,11 @@ func TestUpdateActor_ReassignsPoolAcrossSuspendResume(t *testing.T) { t.Fatalf("CreateActor failed: %v", err) } - if _, err := tc.client.ResumeActor(context.Background(), &ateapipb.ResumeActorRequest{Atespace: testAtespace, ActorId: id}); err != nil { + if _, err := tc.client.ResumeActor(context.Background(), &ateapipb.ResumeActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}}); err != nil { t.Fatalf("first ResumeActor failed: %v", err) } - getResp, err := tc.client.GetActor(context.Background(), &ateapipb.GetActorRequest{Atespace: testAtespace, ActorId: id}) + getResp, err := tc.client.GetActor(context.Background(), &ateapipb.GetActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}}) if err != nil { t.Fatalf("GetActor failed: %v", err) } @@ -1842,8 +1812,8 @@ func TestUpdateActor_ReassignsPoolAcrossSuspendResume(t *testing.T) { t.Fatalf("expected actor to first resume onto worker-a, got ateom_pod_name=%q", got) } - if _, err := tc.client.UpdateActor(context.Background(), &ateapipb.UpdateActorRequest{Atespace: testAtespace, - ActorId: id, + if _, err := tc.client.UpdateActor(context.Background(), &ateapipb.UpdateActorRequest{ + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}, WorkerSelector: &ateapipb.Selector{ MatchLabels: map[string]string{"tier": "b"}, }, @@ -1851,14 +1821,14 @@ func TestUpdateActor_ReassignsPoolAcrossSuspendResume(t *testing.T) { t.Fatalf("UpdateActor failed: %v", err) } - if _, err := tc.client.SuspendActor(context.Background(), &ateapipb.SuspendActorRequest{Atespace: testAtespace, ActorId: id}); err != nil { + if _, err := tc.client.SuspendActor(context.Background(), &ateapipb.SuspendActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}}); err != nil { t.Fatalf("SuspendActor failed: %v", err) } - if _, err := tc.client.ResumeActor(context.Background(), &ateapipb.ResumeActorRequest{Atespace: testAtespace, ActorId: id}); err != nil { + if _, err := tc.client.ResumeActor(context.Background(), &ateapipb.ResumeActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}}); err != nil { t.Fatalf("second ResumeActor failed: %v", err) } - getResp, err = tc.client.GetActor(context.Background(), &ateapipb.GetActorRequest{Atespace: testAtespace, ActorId: id}) + getResp, err = tc.client.GetActor(context.Background(), &ateapipb.GetActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}}) if err != nil { t.Fatalf("GetActor failed: %v", err) } @@ -1891,37 +1861,37 @@ func TestValidation(t *testing.T) { }{ { "missing namespace", - &ateapipb.CreateActorRequest{Atespace: testAtespace, ActorTemplateName: "tmpl1", ActorId: "id1"}, + &ateapipb.CreateActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, ActorTemplateName: "tmpl1"}, "actor_template_namespace is required"}, { "missing template name", - &ateapipb.CreateActorRequest{Atespace: testAtespace, ActorTemplateNamespace: "ns1", ActorId: "id1"}, + &ateapipb.CreateActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, ActorTemplateNamespace: "ns1"}, "actor_template_name is required"}, { "missing actor id", - &ateapipb.CreateActorRequest{Atespace: testAtespace, ActorTemplateNamespace: "ns1", ActorTemplateName: "tmpl1"}, + &ateapipb.CreateActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace}, ActorTemplateNamespace: "ns1", ActorTemplateName: "tmpl1"}, "actor_id is required"}, { "invalid actor id (capitals)", - &ateapipb.CreateActorRequest{Atespace: testAtespace, ActorTemplateNamespace: "ns1", ActorTemplateName: "tmpl1", ActorId: "ID1"}, + &ateapipb.CreateActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "ID1"}, ActorTemplateNamespace: "ns1", ActorTemplateName: "tmpl1"}, "invalid actor_id: must start and end with a lower case alphanumeric character, and consist only of lower case alphanumeric characters or '-'"}, { "invalid actor id (special chars)", - &ateapipb.CreateActorRequest{Atespace: testAtespace, ActorTemplateNamespace: "ns1", ActorTemplateName: "tmpl1", ActorId: "id_1"}, + &ateapipb.CreateActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id_1"}, ActorTemplateNamespace: "ns1", ActorTemplateName: "tmpl1"}, "invalid actor_id: must start and end with a lower case alphanumeric character, and consist only of lower case alphanumeric characters or '-'"}, { "invalid worker_selector label key", - &ateapipb.CreateActorRequest{Atespace: testAtespace, ActorTemplateNamespace: "ns1", ActorTemplateName: "tmpl1", ActorId: "id1", WorkerSelector: &ateapipb.Selector{MatchLabels: map[string]string{"bad key!": "x"}}}, + &ateapipb.CreateActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, ActorTemplateNamespace: "ns1", ActorTemplateName: "tmpl1", WorkerSelector: &ateapipb.Selector{MatchLabels: map[string]string{"bad key!": "x"}}}, `invalid worker_selector label key "bad key!": name part must consist of alphanumeric characters, '-', '_' or '.', and must start and end with an alphanumeric character (e.g. 'MyName', or 'my.name', or '123-abc', regex used for validation is '([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9]')`, }, { "invalid worker_selector label value", - &ateapipb.CreateActorRequest{Atespace: testAtespace, ActorTemplateNamespace: "ns1", ActorTemplateName: "tmpl1", ActorId: "id1", WorkerSelector: &ateapipb.Selector{MatchLabels: map[string]string{"tier": "not valid!"}}}, + &ateapipb.CreateActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, ActorTemplateNamespace: "ns1", ActorTemplateName: "tmpl1", WorkerSelector: &ateapipb.Selector{MatchLabels: map[string]string{"tier": "not valid!"}}}, `invalid worker_selector label value "not valid!" for key "tier": a valid label must be an empty string or consist of alphanumeric characters, '-', '_' or '.', and must start and end with an alphanumeric character (e.g. 'MyValue', or 'my_value', or '12345', regex used for validation is '(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])?')`, }, { "too many worker_selector match_labels", - &ateapipb.CreateActorRequest{Atespace: testAtespace, ActorTemplateNamespace: "ns1", ActorTemplateName: "tmpl1", ActorId: "id1", WorkerSelector: &ateapipb.Selector{MatchLabels: selectorLabelsOfSize(11)}}, + &ateapipb.CreateActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, ActorTemplateNamespace: "ns1", ActorTemplateName: "tmpl1", WorkerSelector: &ateapipb.Selector{MatchLabels: selectorLabelsOfSize(11)}}, "worker_selector has 11 match_labels entries, exceeding the limit of 10", }, } @@ -1939,7 +1909,7 @@ func TestValidation(t *testing.T) { req *ateapipb.GetActorRequest wantMsg string }{ - {"missing id", &ateapipb.GetActorRequest{Atespace: testAtespace}, "id is required"}, + {"missing id", &ateapipb.GetActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace}}, "id is required"}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { @@ -1955,7 +1925,7 @@ func TestValidation(t *testing.T) { req *ateapipb.ResumeActorRequest wantMsg string }{ - {"missing id", &ateapipb.ResumeActorRequest{Atespace: testAtespace}, "id is required"}, + {"missing id", &ateapipb.ResumeActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace}}, "id is required"}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { @@ -1971,7 +1941,7 @@ func TestValidation(t *testing.T) { req *ateapipb.SuspendActorRequest wantMsg string }{ - {"missing id", &ateapipb.SuspendActorRequest{Atespace: testAtespace}, "id is required"}, + {"missing id", &ateapipb.SuspendActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace}}, "id is required"}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { @@ -1987,20 +1957,20 @@ func TestValidation(t *testing.T) { req *ateapipb.UpdateActorRequest wantMsg string }{ - {"missing id", &ateapipb.UpdateActorRequest{Atespace: testAtespace}, "actor_id is required"}, + {"missing id", &ateapipb.UpdateActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace}}, "actor_id is required"}, { "invalid worker_selector label key", - &ateapipb.UpdateActorRequest{Atespace: testAtespace, ActorId: "id1", WorkerSelector: &ateapipb.Selector{MatchLabels: map[string]string{"bad key!": "x"}}}, + &ateapipb.UpdateActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, WorkerSelector: &ateapipb.Selector{MatchLabels: map[string]string{"bad key!": "x"}}}, `invalid worker_selector label key "bad key!": name part must consist of alphanumeric characters, '-', '_' or '.', and must start and end with an alphanumeric character (e.g. 'MyName', or 'my.name', or '123-abc', regex used for validation is '([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9]')`, }, { "invalid worker_selector label value", - &ateapipb.UpdateActorRequest{Atespace: testAtespace, ActorId: "id1", WorkerSelector: &ateapipb.Selector{MatchLabels: map[string]string{"tier": "not valid!"}}}, + &ateapipb.UpdateActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, WorkerSelector: &ateapipb.Selector{MatchLabels: map[string]string{"tier": "not valid!"}}}, `invalid worker_selector label value "not valid!" for key "tier": a valid label must be an empty string or consist of alphanumeric characters, '-', '_' or '.', and must start and end with an alphanumeric character (e.g. 'MyValue', or 'my_value', or '12345', regex used for validation is '(([A-Za-z0-9][-A-Za-z0-9_.]*)?[A-Za-z0-9])?')`, }, { "too many worker_selector match_labels", - &ateapipb.UpdateActorRequest{Atespace: testAtespace, ActorId: "id1", WorkerSelector: &ateapipb.Selector{MatchLabels: selectorLabelsOfSize(11)}}, + &ateapipb.UpdateActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, WorkerSelector: &ateapipb.Selector{MatchLabels: selectorLabelsOfSize(11)}}, "worker_selector has 11 match_labels entries, exceeding the limit of 10", }, } @@ -2018,9 +1988,9 @@ func TestValidation(t *testing.T) { req *ateapipb.DeleteActorRequest wantMsg string }{ - {"missing id", &ateapipb.DeleteActorRequest{Atespace: testAtespace}, "actor_id is required"}, - {"invalid actor id (capitals)", &ateapipb.DeleteActorRequest{Atespace: testAtespace, ActorId: "ID1"}, "invalid actor_id: must start and end with a lower case alphanumeric character, and consist only of lower case alphanumeric characters or '-'"}, - {"invalid actor id (special chars)", &ateapipb.DeleteActorRequest{Atespace: testAtespace, ActorId: "id_1"}, "invalid actor_id: must start and end with a lower case alphanumeric character, and consist only of lower case alphanumeric characters or '-'"}, + {"missing id", &ateapipb.DeleteActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace}}, "actor_id is required"}, + {"invalid actor id (capitals)", &ateapipb.DeleteActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "ID1"}}, "invalid actor_id: must start and end with a lower case alphanumeric character, and consist only of lower case alphanumeric characters or '-'"}, + {"invalid actor id (special chars)", &ateapipb.DeleteActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id_1"}}, "invalid actor_id: must start and end with a lower case alphanumeric character, and consist only of lower case alphanumeric characters or '-'"}, } for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { @@ -2041,10 +2011,9 @@ func TestResumeActor_LockConflict(t *testing.T) { createWorkerPod(t, tc, ns, "worker-1", "node1", "pool1") _, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ - Atespace: testAtespace, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: "id1", }) if err != nil { t.Fatalf("CreateActor failed: %v", err) @@ -2058,8 +2027,7 @@ func TestResumeActor_LockConflict(t *testing.T) { errChan := make(chan error, 1) go func() { _, err := tc.client.ResumeActor(context.Background(), &ateapipb.ResumeActorRequest{ - Atespace: testAtespace, - ActorId: id, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}, }) errChan <- err }() @@ -2069,8 +2037,7 @@ func TestResumeActor_LockConflict(t *testing.T) { // Launch Request B (should fail due to lock conflict) _, err = tc.client.ResumeActor(context.Background(), &ateapipb.ResumeActorRequest{ - Atespace: testAtespace, - ActorId: id, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}, }) assertGrpcError(t, err, codes.Aborted, "another operation is in progress for this actor") @@ -2091,10 +2058,9 @@ func TestResumeActor_DanglingWorker(t *testing.T) { createWorkerPod(t, tc, ns, "worker-a", "node1", "pool1") _, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ - Atespace: testAtespace, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: "id1", }) if err != nil { t.Fatalf("CreateActor failed: %v", err) @@ -2106,8 +2072,7 @@ func TestResumeActor_DanglingWorker(t *testing.T) { // 3. Call ResumeActor -> Expect failure _, err = tc.client.ResumeActor(context.Background(), &ateapipb.ResumeActorRequest{ - Atespace: testAtespace, - ActorId: id, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}, }) if err == nil { t.Fatalf("expected ResumeActor to fail due to atelet error") @@ -2115,8 +2080,7 @@ func TestResumeActor_DanglingWorker(t *testing.T) { // Verify actor state is RESUMING with worker A assigned getResp, err := tc.client.GetActor(context.Background(), &ateapipb.GetActorRequest{ - Atespace: testAtespace, - ActorId: id, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}, }) if err != nil { t.Fatalf("GetActor failed: %v", err) @@ -2140,8 +2104,7 @@ func TestResumeActor_DanglingWorker(t *testing.T) { // 8. Call ResumeActor again -> Expect success and picking Worker B! _, err = tc.client.ResumeActor(context.Background(), &ateapipb.ResumeActorRequest{ - Atespace: testAtespace, - ActorId: id, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}, }) if err != nil { t.Fatalf("ResumeActor failed on retry: %v", err) @@ -2175,10 +2138,9 @@ func TestSuspendActor_DanglingWorker(t *testing.T) { createWorkerPod(t, tc, ns, "worker-1", "node1", "pool1") _, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ - Atespace: testAtespace, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: "id1", }) if err != nil { t.Fatalf("CreateActor failed: %v", err) @@ -2187,8 +2149,7 @@ func TestSuspendActor_DanglingWorker(t *testing.T) { // Resume first to make it running _, err = tc.client.ResumeActor(context.Background(), &ateapipb.ResumeActorRequest{ - Atespace: testAtespace, - ActorId: id, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}, }) if err != nil { t.Fatalf("ResumeActor failed: %v", err) @@ -2204,8 +2165,7 @@ func TestSuspendActor_DanglingWorker(t *testing.T) { } _, err = tc.client.SuspendActor(context.Background(), &ateapipb.SuspendActorRequest{ - Atespace: testAtespace, - ActorId: id, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}, }) if err != nil { t.Fatalf("SuspendActor failed: %v", err) @@ -2213,8 +2173,7 @@ func TestSuspendActor_DanglingWorker(t *testing.T) { // 4. Verify it becomes SUSPENDED in Redis getResp, err := tc.client.GetActor(context.Background(), &ateapipb.GetActorRequest{ - Atespace: testAtespace, - ActorId: id, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: id}, }) if err != nil { t.Fatalf("GetActor failed: %v", err) @@ -2235,26 +2194,23 @@ func TestDeleteActor_Success(t *testing.T) { createTemplate(t, tc, ns) _, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ - Atespace: testAtespace, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: "id1", }) if err != nil { t.Fatalf("CreateActor failed: %v", err) } _, err = tc.client.DeleteActor(context.Background(), &ateapipb.DeleteActorRequest{ - Atespace: testAtespace, - ActorId: "id1", + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, }) if err != nil { t.Fatalf("DeleteActor failed: %v", err) } _, err = tc.client.GetActor(context.Background(), &ateapipb.GetActorRequest{ - Atespace: testAtespace, - ActorId: "id1", + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, }) assertGrpcError(t, err, codes.NotFound, "Actor id1 not found") } @@ -2268,26 +2224,23 @@ func TestDeleteActor_NotSuspended(t *testing.T) { createWorkerPod(t, tc, ns, "worker-1", "node1", "pool1") _, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ - Atespace: testAtespace, + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: "id1", }) if err != nil { t.Fatalf("CreateActor failed: %v", err) } _, err = tc.client.ResumeActor(context.Background(), &ateapipb.ResumeActorRequest{ - Atespace: testAtespace, - ActorId: "id1", + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, }) if err != nil { t.Fatalf("ResumeActor failed: %v", err) } _, err = tc.client.DeleteActor(context.Background(), &ateapipb.DeleteActorRequest{ - Atespace: testAtespace, - ActorId: "id1", + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "id1"}, }) assertGrpcError(t, err, codes.FailedPrecondition, "Actor id1 is not suspended (status: STATUS_RUNNING)") } @@ -2298,8 +2251,7 @@ func TestDeleteActor_NotFound(t *testing.T) { defer tc.cleanup() _, err := tc.client.DeleteActor(context.Background(), &ateapipb.DeleteActorRequest{ - Atespace: testAtespace, - ActorId: "non-existent", + ActorRef: &ateapipb.ActorRef{Atespace: testAtespace, Name: "non-existent"}, }) assertGrpcError(t, err, codes.NotFound, "Actor non-existent not found") } @@ -2330,10 +2282,9 @@ func TestCreateActor_AtespaceNotFound(t *testing.T) { // The template exists, but "missing-as" was never created. The template // check fires first, so reaching this error proves the atespace check ran. _, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ + ActorRef: &ateapipb.ActorRef{Atespace: "missing-as", Name: "id1"}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: "id1", - Atespace: "missing-as", }) assertGrpcError(t, err, codes.FailedPrecondition, "Atespace missing-as not found") } @@ -2355,10 +2306,9 @@ func TestCreateAtespace_Success(t *testing.T) { // An actor can now be created into the new atespace. if _, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ + ActorRef: &ateapipb.ActorRef{Atespace: "team-a", Name: "id1"}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: "id1", - Atespace: "team-a", }); err != nil { t.Errorf("CreateActor into freshly created atespace failed: %v", err) } @@ -2472,10 +2422,9 @@ func TestDeleteAtespace_NonEmpty_Rejected(t *testing.T) { t.Fatalf("CreateAtespace failed: %v", err) } if _, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ + ActorRef: &ateapipb.ActorRef{Atespace: "team-a", Name: "id1"}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: "id1", - Atespace: "team-a", }); err != nil { t.Fatalf("CreateActor failed: %v", err) } @@ -2500,10 +2449,9 @@ func TestDeleteAtespace_ScopedToTargetAtespace(t *testing.T) { // Actor only in team-b. if _, err := tc.client.CreateActor(context.Background(), &ateapipb.CreateActorRequest{ + ActorRef: &ateapipb.ActorRef{Atespace: "team-b", Name: "id1"}, ActorTemplateNamespace: ns, ActorTemplateName: "tmpl1", - ActorId: "id1", - Atespace: "team-b", }); err != nil { t.Fatalf("CreateActor failed: %v", err) } diff --git a/cmd/ateapi/internal/controlapi/get_actor.go b/cmd/ateapi/internal/controlapi/get_actor.go index ebac995b9..3338749e2 100644 --- a/cmd/ateapi/internal/controlapi/get_actor.go +++ b/cmd/ateapi/internal/controlapi/get_actor.go @@ -29,9 +29,9 @@ func (s *Service) GetActor(ctx context.Context, req *ateapipb.GetActorRequest) ( if err := validateGetActorRequest(req); err != nil { return nil, err } - actor, err := s.persistence.GetActor(ctx, req.GetAtespace(), req.GetActorId()) + actor, err := s.persistence.GetActor(ctx, req.GetActorRef().GetAtespace(), req.GetActorRef().GetName()) if errors.Is(err, store.ErrNotFound) { - return nil, status.Errorf(codes.NotFound, "Actor %s not found", req.GetActorId()) + return nil, status.Errorf(codes.NotFound, "Actor %s not found", req.GetActorRef().GetName()) } else if err != nil { return nil, fmt.Errorf("while getting actor from DB: %w", err) } @@ -41,10 +41,10 @@ func (s *Service) GetActor(ctx context.Context, req *ateapipb.GetActorRequest) ( } func validateGetActorRequest(req *ateapipb.GetActorRequest) error { - if req.GetActorId() == "" { + if req.GetActorRef().GetName() == "" { return status.Error(codes.InvalidArgument, "id is required") } - if req.GetAtespace() == "" { + if req.GetActorRef().GetAtespace() == "" { return status.Error(codes.InvalidArgument, "atespace is required") } return nil diff --git a/cmd/ateapi/internal/controlapi/pause_actor.go b/cmd/ateapi/internal/controlapi/pause_actor.go index f76bc4c79..c90180b82 100644 --- a/cmd/ateapi/internal/controlapi/pause_actor.go +++ b/cmd/ateapi/internal/controlapi/pause_actor.go @@ -29,13 +29,13 @@ func (s *Service) PauseActor(ctx context.Context, req *ateapipb.PauseActorReques return nil, err } - actor, err := s.actorWorkflow.PauseActor(ctx, req.GetAtespace(), req.GetActorId()) + actor, err := s.actorWorkflow.PauseActor(ctx, req.GetActorRef().GetAtespace(), req.GetActorRef().GetName()) if err != nil { if errors.Is(err, store.ErrPersistenceRetry) { return nil, status.Error(codes.Aborted, "concurrent update conflict, please retry") } if errors.Is(err, store.ErrNotFound) { - return nil, status.Errorf(codes.NotFound, "Actor %s not found", req.GetActorId()) + return nil, status.Errorf(codes.NotFound, "Actor %s not found", req.GetActorRef().GetName()) } return nil, err } @@ -44,10 +44,10 @@ func (s *Service) PauseActor(ctx context.Context, req *ateapipb.PauseActorReques } func validatePauseActorRequest(req *ateapipb.PauseActorRequest) error { - if req.GetActorId() == "" { + if req.GetActorRef().GetName() == "" { return status.Error(codes.InvalidArgument, "id is required") } - if req.GetAtespace() == "" { + if req.GetActorRef().GetAtespace() == "" { return status.Error(codes.InvalidArgument, "atespace is required") } return nil diff --git a/cmd/ateapi/internal/controlapi/resume_actor.go b/cmd/ateapi/internal/controlapi/resume_actor.go index 623a29efb..37506e623 100644 --- a/cmd/ateapi/internal/controlapi/resume_actor.go +++ b/cmd/ateapi/internal/controlapi/resume_actor.go @@ -29,13 +29,13 @@ func (s *Service) ResumeActor(ctx context.Context, req *ateapipb.ResumeActorRequ return nil, err } - actor, err := s.actorWorkflow.ResumeActor(ctx, req.GetAtespace(), req.GetActorId(), req.GetBoot()) + actor, err := s.actorWorkflow.ResumeActor(ctx, req.GetActorRef().GetAtespace(), req.GetActorRef().GetName(), req.GetBoot()) if err != nil { if errors.Is(err, store.ErrPersistenceRetry) { return nil, status.Error(codes.Aborted, "concurrent update conflict, please retry") } if errors.Is(err, store.ErrNotFound) { - return nil, status.Errorf(codes.NotFound, "Actor %s not found", req.GetActorId()) + return nil, status.Errorf(codes.NotFound, "Actor %s not found", req.GetActorRef().GetName()) } return nil, err } @@ -44,10 +44,10 @@ func (s *Service) ResumeActor(ctx context.Context, req *ateapipb.ResumeActorRequ } func validateResumeActorRequest(req *ateapipb.ResumeActorRequest) error { - if req.GetActorId() == "" { + if req.GetActorRef().GetName() == "" { return status.Error(codes.InvalidArgument, "id is required") } - if req.GetAtespace() == "" { + if req.GetActorRef().GetAtespace() == "" { return status.Error(codes.InvalidArgument, "atespace is required") } return nil diff --git a/cmd/ateapi/internal/controlapi/suspend_actor.go b/cmd/ateapi/internal/controlapi/suspend_actor.go index 531f2a2da..6abdc1c12 100644 --- a/cmd/ateapi/internal/controlapi/suspend_actor.go +++ b/cmd/ateapi/internal/controlapi/suspend_actor.go @@ -29,13 +29,13 @@ func (s *Service) SuspendActor(ctx context.Context, req *ateapipb.SuspendActorRe return nil, err } - actor, err := s.actorWorkflow.SuspendActor(ctx, req.GetAtespace(), req.GetActorId()) + actor, err := s.actorWorkflow.SuspendActor(ctx, req.GetActorRef().GetAtespace(), req.GetActorRef().GetName()) if err != nil { if errors.Is(err, store.ErrPersistenceRetry) { return nil, status.Error(codes.Aborted, "concurrent update conflict, please retry") } if errors.Is(err, store.ErrNotFound) { - return nil, status.Errorf(codes.NotFound, "Actor %s not found", req.GetActorId()) + return nil, status.Errorf(codes.NotFound, "Actor %s not found", req.GetActorRef().GetName()) } return nil, err } @@ -44,10 +44,10 @@ func (s *Service) SuspendActor(ctx context.Context, req *ateapipb.SuspendActorRe } func validateSuspendActorRequest(req *ateapipb.SuspendActorRequest) error { - if req.GetActorId() == "" { + if req.GetActorRef().GetName() == "" { return status.Error(codes.InvalidArgument, "id is required") } - if req.GetAtespace() == "" { + if req.GetActorRef().GetAtespace() == "" { return status.Error(codes.InvalidArgument, "atespace is required") } return nil diff --git a/cmd/ateapi/internal/controlapi/update_actor.go b/cmd/ateapi/internal/controlapi/update_actor.go index 0aeb35cbd..0e54f7da6 100644 --- a/cmd/ateapi/internal/controlapi/update_actor.go +++ b/cmd/ateapi/internal/controlapi/update_actor.go @@ -31,10 +31,10 @@ func (s *Service) UpdateActor(ctx context.Context, req *ateapipb.UpdateActorRequ return nil, err } - actor, err := s.persistence.GetActor(ctx, req.GetAtespace(), req.GetActorId()) + actor, err := s.persistence.GetActor(ctx, req.GetActorRef().GetAtespace(), req.GetActorRef().GetName()) if err != nil { if errors.Is(err, store.ErrNotFound) { - return nil, status.Errorf(codes.NotFound, "Actor %s not found", req.GetActorId()) + return nil, status.Errorf(codes.NotFound, "Actor %s not found", req.GetActorRef().GetName()) } return nil, fmt.Errorf("while getting actor: %w", err) } @@ -51,13 +51,13 @@ func (s *Service) UpdateActor(ctx context.Context, req *ateapipb.UpdateActorRequ } func validateUpdateActorRequest(req *ateapipb.UpdateActorRequest) error { - if req.GetActorId() == "" { + if req.GetActorRef().GetName() == "" { return status.Error(codes.InvalidArgument, "actor_id is required") } - if req.GetAtespace() == "" { + if req.GetActorRef().GetAtespace() == "" { return status.Error(codes.InvalidArgument, "atespace is required") } - if err := resources.ValidateAtespace(req.GetAtespace()); err != nil { + if err := resources.ValidateAtespace(req.GetActorRef().GetAtespace()); err != nil { return status.Error(codes.InvalidArgument, err.Error()) } if err := validateSelector(req.GetWorkerSelector()); err != nil { diff --git a/cmd/atecontroller/internal/controllers/actortemplate_controller.go b/cmd/atecontroller/internal/controllers/actortemplate_controller.go index 69904bc41..4832b4fe5 100644 --- a/cmd/atecontroller/internal/controllers/actortemplate_controller.go +++ b/cmd/atecontroller/internal/controllers/actortemplate_controller.go @@ -88,8 +88,7 @@ func (r *ActorTemplateReconciler) Reconcile(ctx context.Context, req ctrl.Reques } createReq := &ateapipb.CreateActorRequest{ - ActorId: actorID, - Atespace: at.ObjectMeta.Namespace, + ActorRef: &ateapipb.ActorRef{Atespace: at.ObjectMeta.Namespace, Name: actorID}, ActorTemplateNamespace: at.ObjectMeta.Namespace, ActorTemplateName: at.ObjectMeta.Name, } @@ -118,8 +117,7 @@ func (r *ActorTemplateReconciler) Reconcile(ctx context.Context, req ctrl.Reques // TODO: Maybe this should go through a different RPC dedicated to // booting an actor from scratch. resumeReq := &ateapipb.ResumeActorRequest{ - ActorId: at.Status.GoldenActorID, - Atespace: at.ObjectMeta.Namespace, + ActorRef: &ateapipb.ActorRef{Atespace: at.ObjectMeta.Namespace, Name: at.Status.GoldenActorID}, } _, err := r.AteClient.ResumeActor(ctx, resumeReq) if err != nil { @@ -145,8 +143,7 @@ func (r *ActorTemplateReconciler) Reconcile(ctx context.Context, req ctrl.Reques // from it. req := &ateapipb.SuspendActorRequest{ - ActorId: at.Status.GoldenActorID, - Atespace: at.ObjectMeta.Namespace, + ActorRef: &ateapipb.ActorRef{Atespace: at.ObjectMeta.Namespace, Name: at.Status.GoldenActorID}, } resp, err := r.AteClient.SuspendActor(ctx, req) if err != nil { diff --git a/cmd/atenet/internal/router/extproc_test.go b/cmd/atenet/internal/router/extproc_test.go index dc16ba169..bfd988691 100644 --- a/cmd/atenet/internal/router/extproc_test.go +++ b/cmd/atenet/internal/router/extproc_test.go @@ -179,8 +179,8 @@ func TestExtProcHeadersEvaluation(t *testing.T) { t.Run(tc.name, func(t *testing.T) { clientMock := &mockClient{ resumeFn: func(ctx context.Context, in *ateapipb.ResumeActorRequest, opts ...grpc.CallOption) (*ateapipb.ResumeActorResponse, error) { - if in.GetActorId() != testUUID { - t.Errorf("unexpected identifier parsed in test context: %s", in.GetActorId()) + if in.GetActorRef().GetName() != testUUID { + t.Errorf("unexpected identifier parsed in test context: %s", in.GetActorRef().GetName()) } if tc.resumeErr != nil { return nil, tc.resumeErr diff --git a/cmd/atenet/internal/router/resumer.go b/cmd/atenet/internal/router/resumer.go index d3b415f7c..f9c6da683 100644 --- a/cmd/atenet/internal/router/resumer.go +++ b/cmd/atenet/internal/router/resumer.go @@ -70,8 +70,7 @@ func (r *ActorResumer) ResumeActor(ctx context.Context, atespace, actorID string err := wait.ExponentialBackoffWithContext(bgCtx, backoff, func(ctx context.Context) (bool, error) { var err error resumeResp, err = r.apiClient.ResumeActor(ctx, &ateapipb.ResumeActorRequest{ - ActorId: actorID, - Atespace: atespace, + ActorRef: &ateapipb.ActorRef{Atespace: atespace, Name: actorID}, }) if err == nil { return true, nil diff --git a/cmd/kubectl-ate/internal/cmd/create_actor.go b/cmd/kubectl-ate/internal/cmd/create_actor.go index 9f9ea5d46..69b81ae23 100644 --- a/cmd/kubectl-ate/internal/cmd/create_actor.go +++ b/cmd/kubectl-ate/internal/cmd/create_actor.go @@ -48,8 +48,7 @@ var createActorCmd = &cobra.Command{ resp, err := apiClient.CreateActor(ctx, &ateapipb.CreateActorRequest{ ActorTemplateNamespace: parts[0], ActorTemplateName: parts[1], - ActorId: actorID, - Atespace: atespaceFlag, + ActorRef: &ateapipb.ActorRef{Atespace: atespaceFlag, Name: actorID}, }) if err != nil { return fmt.Errorf("failed to create actor: %w", err) diff --git a/cmd/kubectl-ate/internal/cmd/delete_actor.go b/cmd/kubectl-ate/internal/cmd/delete_actor.go index 27cfee82f..895fb49a3 100644 --- a/cmd/kubectl-ate/internal/cmd/delete_actor.go +++ b/cmd/kubectl-ate/internal/cmd/delete_actor.go @@ -38,8 +38,7 @@ var deleteActorCmd = &cobra.Command{ id := args[0] _, err = c.ControlClient.DeleteActor(ctx, &ateapipb.DeleteActorRequest{ - ActorId: id, - Atespace: deleteAtespaceFlag, + ActorRef: &ateapipb.ActorRef{Atespace: deleteAtespaceFlag, Name: id}, }) if err != nil { return err diff --git a/cmd/kubectl-ate/internal/cmd/get_actors.go b/cmd/kubectl-ate/internal/cmd/get_actors.go index 91c4a60f3..8d5e61ab8 100644 --- a/cmd/kubectl-ate/internal/cmd/get_actors.go +++ b/cmd/kubectl-ate/internal/cmd/get_actors.go @@ -52,7 +52,7 @@ var getActorsCmd = &cobra.Command{ if getActorsAtespaceFlag == "" { return fmt.Errorf("--atespace is required when getting a specific actor") } - resp, err := apiClient.GetActor(ctx, &ateapipb.GetActorRequest{ActorId: args[0], Atespace: getActorsAtespaceFlag}) + resp, err := apiClient.GetActor(ctx, &ateapipb.GetActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: getActorsAtespaceFlag, Name: args[0]}}) if err != nil { return fmt.Errorf("failed to get actor: %w", err) } diff --git a/cmd/kubectl-ate/internal/cmd/logs_actors.go b/cmd/kubectl-ate/internal/cmd/logs_actors.go index d7ab65bf2..d552b24ab 100644 --- a/cmd/kubectl-ate/internal/cmd/logs_actors.go +++ b/cmd/kubectl-ate/internal/cmd/logs_actors.go @@ -109,7 +109,7 @@ func (r *LogsActorRunner) Run(ctx context.Context, actorID string) error { } func (r *LogsActorRunner) runOneShot(ctx context.Context, actorID string) error { - actorResp, err := r.apiClient.GetActor(ctx, &ateapipb.GetActorRequest{ActorId: actorID, Atespace: r.atespace}) + actorResp, err := r.apiClient.GetActor(ctx, &ateapipb.GetActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: r.atespace, Name: actorID}}) if err != nil { return fmt.Errorf("failed to get actor: %w", err) } @@ -156,7 +156,7 @@ func (r *LogsActorRunner) runFollow(ctx context.Context, actorID string) error { default: } - actorResp, err := r.apiClient.GetActor(ctx, &ateapipb.GetActorRequest{ActorId: actorID, Atespace: r.atespace}) + actorResp, err := r.apiClient.GetActor(ctx, &ateapipb.GetActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: r.atespace, Name: actorID}}) if err != nil { if status.Code(err) == codes.NotFound { return fmt.Errorf("actor %s not found: %w", actorID, err) @@ -264,7 +264,7 @@ func (r *LogsActorRunner) startMigrationMonitor( case <-ctx.Done(): return case <-ticker.C: - resp, err := r.apiClient.GetActor(ctx, &ateapipb.GetActorRequest{ActorId: actorID, Atespace: r.atespace}) + resp, err := r.apiClient.GetActor(ctx, &ateapipb.GetActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: r.atespace, Name: actorID}}) if err == nil { act := resp.GetActor() if act.GetStatus() != ateapipb.Actor_STATUS_RUNNING || act.GetAteomPodName() != currentPod { diff --git a/cmd/kubectl-ate/internal/cmd/logs_actors_test.go b/cmd/kubectl-ate/internal/cmd/logs_actors_test.go index 97ce505e8..e7ec18de3 100644 --- a/cmd/kubectl-ate/internal/cmd/logs_actors_test.go +++ b/cmd/kubectl-ate/internal/cmd/logs_actors_test.go @@ -187,8 +187,8 @@ func TestLogsActorRunner_Run_OneShotSuccess(t *testing.T) { mockAPI := &mockAteAPIClient{ GetActorFunc: func(ctx context.Context, in *ateapipb.GetActorRequest, opts ...grpc.CallOption) (*ateapipb.GetActorResponse, error) { - if in.ActorId != actorID { - return nil, fmt.Errorf("unexpected actor ID: %s", in.ActorId) + if in.GetActorRef().GetName() != actorID { + return nil, fmt.Errorf("unexpected actor ID: %s", in.GetActorRef().GetName()) } return &ateapipb.GetActorResponse{ Actor: &ateapipb.Actor{ diff --git a/cmd/kubectl-ate/internal/cmd/pause_actor.go b/cmd/kubectl-ate/internal/cmd/pause_actor.go index cad22b3a4..f682cbce8 100644 --- a/cmd/kubectl-ate/internal/cmd/pause_actor.go +++ b/cmd/kubectl-ate/internal/cmd/pause_actor.go @@ -38,8 +38,7 @@ var pauseActorCmd = &cobra.Command{ defer apiClient.Close() resp, err := apiClient.PauseActor(ctx, &ateapipb.PauseActorRequest{ - ActorId: args[0], - Atespace: pauseAtespaceFlag, + ActorRef: &ateapipb.ActorRef{Atespace: pauseAtespaceFlag, Name: args[0]}, }) if err != nil { return fmt.Errorf("failed to pause actor: %w", err) diff --git a/cmd/kubectl-ate/internal/cmd/resume_actor.go b/cmd/kubectl-ate/internal/cmd/resume_actor.go index 5bd04b270..0397385d1 100644 --- a/cmd/kubectl-ate/internal/cmd/resume_actor.go +++ b/cmd/kubectl-ate/internal/cmd/resume_actor.go @@ -39,9 +39,8 @@ var resumeActorCmd = &cobra.Command{ defer apiClient.Close() resp, err := apiClient.ResumeActor(ctx, &ateapipb.ResumeActorRequest{ - ActorId: args[0], + ActorRef: &ateapipb.ActorRef{Atespace: resumeAtespaceFlag, Name: args[0]}, Boot: bootFlag, - Atespace: resumeAtespaceFlag, }) if err != nil { return fmt.Errorf("failed to resume actor: %w", err) diff --git a/cmd/kubectl-ate/internal/cmd/suspend_actor.go b/cmd/kubectl-ate/internal/cmd/suspend_actor.go index c2b534395..ffe524521 100644 --- a/cmd/kubectl-ate/internal/cmd/suspend_actor.go +++ b/cmd/kubectl-ate/internal/cmd/suspend_actor.go @@ -38,8 +38,7 @@ var suspendActorCmd = &cobra.Command{ defer apiClient.Close() resp, err := apiClient.SuspendActor(ctx, &ateapipb.SuspendActorRequest{ - ActorId: args[0], - Atespace: suspendAtespaceFlag, + ActorRef: &ateapipb.ActorRef{Atespace: suspendAtespaceFlag, Name: args[0]}, }) if err != nil { return fmt.Errorf("failed to suspend actor: %w", err) diff --git a/demos/agent-secret/main.go b/demos/agent-secret/main.go index 62ce52634..b5eef7d33 100644 --- a/demos/agent-secret/main.go +++ b/demos/agent-secret/main.go @@ -131,7 +131,7 @@ func suspendSelf(id string) { client := ateapipb.NewControlClient(conn) log.Printf("Yielding compute. Requesting self-suspension for actor %s...", id) - _, err = client.SuspendActor(context.Background(), &ateapipb.SuspendActorRequest{ActorId: id}) + _, err = client.SuspendActor(context.Background(), &ateapipb.SuspendActorRequest{ActorRef: &ateapipb.ActorRef{Name: id}}) if err != nil { log.Printf("Failed to self-suspend: %v", err) } diff --git a/demos/sandbox/client/main.go b/demos/sandbox/client/main.go index 6f97adc02..0203723fe 100644 --- a/demos/sandbox/client/main.go +++ b/demos/sandbox/client/main.go @@ -94,7 +94,7 @@ func main() { defer conn.Close() log.Printf("Resuming actor %s...", *actorID) - _, err = cli.ResumeActor(ctx, &ateapipb.ResumeActorRequest{ActorId: *actorID, Atespace: *atespace}) + _, err = cli.ResumeActor(ctx, &ateapipb.ResumeActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: *atespace, Name: *actorID}}) if err != nil { log.Fatalf("Failed to resume actor: %v", err) } @@ -104,7 +104,7 @@ func main() { defer func() { log.Printf("Suspending actor %s...", *actorID) suspendCtx := context.Background() - _, err := cli.SuspendActor(suspendCtx, &ateapipb.SuspendActorRequest{ActorId: *actorID, Atespace: *atespace}) + _, err := cli.SuspendActor(suspendCtx, &ateapipb.SuspendActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: *atespace, Name: *actorID}}) if err != nil { log.Printf("Failed to suspend actor: %v", err) } else { diff --git a/internal/e2e/suites/demo/demo_test.go b/internal/e2e/suites/demo/demo_test.go index b03756e9e..4938d3d26 100644 --- a/internal/e2e/suites/demo/demo_test.go +++ b/internal/e2e/suites/demo/demo_test.go @@ -141,6 +141,9 @@ func TestDurableDirLifecycle(t *testing.T) { ctx := context.Background() clients := e2e.GetClients() + // CreateActor requires the atespace to exist first. + _, _ = clients.SubstrateAPI.CreateAtespace(ctx, &ateapipb.CreateAtespaceRequest{Name: demoAtespace}) + // Create actor template. at, err := createActorTemplate(ctx, t, clients, nsObj, tc.onCommit, tc.onPause) if err != nil { @@ -154,7 +157,7 @@ func TestDurableDirLifecycle(t *testing.T) { t.Logf("Creating Actor %q using Substrate API...", actorID) createResp, err := clients.SubstrateAPI.CreateActor(ctx, &ateapipb.CreateActorRequest{ - ActorId: actorID, + ActorRef: &ateapipb.ActorRef{Atespace: demoAtespace, Name: actorID}, ActorTemplateNamespace: nsObj.Name, ActorTemplateName: at.Name, }) @@ -164,20 +167,20 @@ func TestDurableDirLifecycle(t *testing.T) { t.Logf("Successfully created Actor: %s", createResp.GetActor().GetActorId()) defer func() { clients.SubstrateAPI.DeleteActor(ctx, &ateapipb.DeleteActorRequest{ - ActorId: actorID, + ActorRef: &ateapipb.ActorRef{Atespace: demoAtespace, Name: actorID}, }) }() // Resuming the actor t.Logf("Resuming Actor %q...", actorID) if _, err := clients.SubstrateAPI.ResumeActor(ctx, &ateapipb.ResumeActorRequest{ - ActorId: actorID, + ActorRef: &ateapipb.ActorRef{Atespace: demoAtespace, Name: actorID}, }); err != nil { t.Fatalf("failed to resume Actor: %v", err) } waitForActorStatus(ctx, t, clients, actorID, ateapipb.Actor_STATUS_RUNNING) - resp, err := callActor(t, actorID) + resp, err := callActor(t, demoAtespace, actorID) if err != nil { t.Fatalf("failed to call actor: %v", err) } @@ -188,7 +191,7 @@ func TestDurableDirLifecycle(t *testing.T) { // t.Logf("Pausing Actor %q...", actorID) if _, err := clients.SubstrateAPI.PauseActor(ctx, &ateapipb.PauseActorRequest{ - ActorId: actorID, + ActorRef: &ateapipb.ActorRef{Atespace: demoAtespace, Name: actorID}, }); err != nil { t.Fatalf("failed to pause Actor: %v", err) } @@ -197,13 +200,13 @@ func TestDurableDirLifecycle(t *testing.T) { // Resuming the actor t.Logf("Resuming Actor %q again...", actorID) if _, err := clients.SubstrateAPI.ResumeActor(ctx, &ateapipb.ResumeActorRequest{ - ActorId: actorID, + ActorRef: &ateapipb.ActorRef{Atespace: demoAtespace, Name: actorID}, }); err != nil { t.Fatalf("failed to resume Actor again: %v", err) } waitForActorStatus(ctx, t, clients, actorID, ateapipb.Actor_STATUS_RUNNING) - resp, err = callActor(t, actorID) + resp, err = callActor(t, demoAtespace, actorID) if err != nil { t.Fatalf("failed to call actor again: %v", err) } @@ -214,7 +217,7 @@ func TestDurableDirLifecycle(t *testing.T) { // t.Logf("Suspending Actor %q...", actorID) if _, err := clients.SubstrateAPI.SuspendActor(ctx, &ateapipb.SuspendActorRequest{ - ActorId: actorID, + ActorRef: &ateapipb.ActorRef{Atespace: demoAtespace, Name: actorID}, }); err != nil { t.Fatalf("failed to suspend Actor: %v", err) } @@ -223,13 +226,13 @@ func TestDurableDirLifecycle(t *testing.T) { // Resuming the actor t.Logf("Resuming Actor %q again...", actorID) if _, err := clients.SubstrateAPI.ResumeActor(ctx, &ateapipb.ResumeActorRequest{ - ActorId: actorID, + ActorRef: &ateapipb.ActorRef{Atespace: demoAtespace, Name: actorID}, }); err != nil { t.Fatalf("failed to resume Actor again: %v", err) } waitForActorStatus(ctx, t, clients, actorID, ateapipb.Actor_STATUS_RUNNING) - resp, err = callActor(t, actorID) + resp, err = callActor(t, demoAtespace, actorID) if err != nil { t.Fatalf("failed to call actor again: %v", err) } @@ -256,8 +259,7 @@ func createActor(ctx context.Context, t *testing.T, clients *e2e.Clients, nsObj t.Logf("Creating Actor %q using Substrate API...", actorID) createResp, err := clients.SubstrateAPI.CreateActor(ctx, &ateapipb.CreateActorRequest{ - Atespace: demoAtespace, - ActorId: actorID, + ActorRef: &ateapipb.ActorRef{Atespace: demoAtespace, Name: actorID}, ActorTemplateNamespace: nsObj.Name, ActorTemplateName: at.Name, }) @@ -267,8 +269,7 @@ func createActor(ctx context.Context, t *testing.T, clients *e2e.Clients, nsObj t.Logf("Successfully created Actor: %s", createResp.GetActor().GetActorId()) defer func() { clients.SubstrateAPI.DeleteActor(ctx, &ateapipb.DeleteActorRequest{ - Atespace: demoAtespace, - ActorId: actorID, + ActorRef: &ateapipb.ActorRef{Atespace: demoAtespace, Name: actorID}, }) }() @@ -312,8 +313,7 @@ func pauseActor(ctx context.Context, t *testing.T, clients *e2e.Clients, nsObj * // Creating an actor t.Logf("Creating Actor %q...", actorID) if _, err := clients.SubstrateAPI.CreateActor(ctx, &ateapipb.CreateActorRequest{ - Atespace: demoAtespace, - ActorId: actorID, + ActorRef: &ateapipb.ActorRef{Atespace: demoAtespace, Name: actorID}, ActorTemplateNamespace: nsObj.Name, ActorTemplateName: at.Name, }); err != nil { @@ -324,8 +324,7 @@ func pauseActor(ctx context.Context, t *testing.T, clients *e2e.Clients, nsObj * // Resuming the actor t.Logf("Resuming Actor %q...", actorID) if _, err := clients.SubstrateAPI.ResumeActor(ctx, &ateapipb.ResumeActorRequest{ - Atespace: demoAtespace, - ActorId: actorID, + ActorRef: &ateapipb.ActorRef{Atespace: demoAtespace, Name: actorID}, }); err != nil { t.Fatalf("failed to resume Actor: %v", err) } @@ -345,8 +344,7 @@ func pauseActor(ctx context.Context, t *testing.T, clients *e2e.Clients, nsObj * // Pausing the actor t.Logf("Pausing Actor %q...", actorID) if _, err := clients.SubstrateAPI.PauseActor(ctx, &ateapipb.PauseActorRequest{ - Atespace: demoAtespace, - ActorId: actorID, + ActorRef: &ateapipb.ActorRef{Atespace: demoAtespace, Name: actorID}, }); err != nil { t.Fatalf("failed to pause Actor: %v", err) } @@ -355,8 +353,7 @@ func pauseActor(ctx context.Context, t *testing.T, clients *e2e.Clients, nsObj * // Resuming the actor again t.Logf("Resuming Actor %q again...", actorID) if _, err := clients.SubstrateAPI.ResumeActor(ctx, &ateapipb.ResumeActorRequest{ - Atespace: demoAtespace, - ActorId: actorID, + ActorRef: &ateapipb.ActorRef{Atespace: demoAtespace, Name: actorID}, }); err != nil { t.Fatalf("failed to resume Actor again: %v", err) } @@ -375,8 +372,7 @@ func pauseActor(ctx context.Context, t *testing.T, clients *e2e.Clients, nsObj * // Suspending the actor before deletion t.Logf("Suspending Actor %q before deletion...", actorID) if _, err := clients.SubstrateAPI.SuspendActor(ctx, &ateapipb.SuspendActorRequest{ - Atespace: demoAtespace, - ActorId: actorID, + ActorRef: &ateapipb.ActorRef{Atespace: demoAtespace, Name: actorID}, }); err != nil { t.Fatalf("failed to suspend Actor: %v", err) } @@ -385,15 +381,13 @@ func pauseActor(ctx context.Context, t *testing.T, clients *e2e.Clients, nsObj * // Deleting the actor t.Logf("Deleting Actor %q...", actorID) if _, err := clients.SubstrateAPI.DeleteActor(ctx, &ateapipb.DeleteActorRequest{ - Atespace: demoAtespace, - ActorId: actorID, + ActorRef: &ateapipb.ActorRef{Atespace: demoAtespace, Name: actorID}, }); err != nil { t.Fatalf("failed to delete Actor: %v", err) } // Verify deletion if _, err := clients.SubstrateAPI.GetActor(ctx, &ateapipb.GetActorRequest{ - Atespace: demoAtespace, - ActorId: actorID, + ActorRef: &ateapipb.ActorRef{Atespace: demoAtespace, Name: actorID}, }); err == nil { t.Fatalf("expected actor %q to be deleted, but it still exists", actorID) } @@ -407,8 +401,7 @@ func suspendActor(ctx context.Context, t *testing.T, clients *e2e.Clients, nsObj // Creating an actor t.Logf("Creating Actor %q...", actorID) if _, err := clients.SubstrateAPI.CreateActor(ctx, &ateapipb.CreateActorRequest{ - Atespace: demoAtespace, - ActorId: actorID, + ActorRef: &ateapipb.ActorRef{Atespace: demoAtespace, Name: actorID}, ActorTemplateNamespace: nsObj.Name, ActorTemplateName: at.Name, }); err != nil { @@ -419,8 +412,7 @@ func suspendActor(ctx context.Context, t *testing.T, clients *e2e.Clients, nsObj // Resuming the actor t.Logf("Resuming Actor %q...", actorID) if _, err := clients.SubstrateAPI.ResumeActor(ctx, &ateapipb.ResumeActorRequest{ - Atespace: demoAtespace, - ActorId: actorID, + ActorRef: &ateapipb.ActorRef{Atespace: demoAtespace, Name: actorID}, }); err != nil { t.Fatalf("failed to resume Actor: %v", err) } @@ -439,8 +431,7 @@ func suspendActor(ctx context.Context, t *testing.T, clients *e2e.Clients, nsObj // Suspending the actor t.Logf("Suspending Actor %q...", actorID) if _, err := clients.SubstrateAPI.SuspendActor(ctx, &ateapipb.SuspendActorRequest{ - Atespace: demoAtespace, - ActorId: actorID, + ActorRef: &ateapipb.ActorRef{Atespace: demoAtespace, Name: actorID}, }); err != nil { t.Fatalf("failed to suspend Actor: %v", err) } @@ -449,8 +440,7 @@ func suspendActor(ctx context.Context, t *testing.T, clients *e2e.Clients, nsObj // Resuming the actor again t.Logf("Resuming Actor %q again...", actorID) if _, err := clients.SubstrateAPI.ResumeActor(ctx, &ateapipb.ResumeActorRequest{ - Atespace: demoAtespace, - ActorId: actorID, + ActorRef: &ateapipb.ActorRef{Atespace: demoAtespace, Name: actorID}, }); err != nil { t.Fatalf("failed to resume Actor again: %v", err) } @@ -469,8 +459,7 @@ func suspendActor(ctx context.Context, t *testing.T, clients *e2e.Clients, nsObj // Suspending the actor before deletion t.Logf("Suspending Actor %q before deletion...", actorID) if _, err := clients.SubstrateAPI.SuspendActor(ctx, &ateapipb.SuspendActorRequest{ - Atespace: demoAtespace, - ActorId: actorID, + ActorRef: &ateapipb.ActorRef{Atespace: demoAtespace, Name: actorID}, }); err != nil { t.Fatalf("failed to suspend Actor: %v", err) } @@ -479,15 +468,13 @@ func suspendActor(ctx context.Context, t *testing.T, clients *e2e.Clients, nsObj // Deleting the actor t.Logf("Deleting Actor %q...", actorID) if _, err := clients.SubstrateAPI.DeleteActor(ctx, &ateapipb.DeleteActorRequest{ - Atespace: demoAtespace, - ActorId: actorID, + ActorRef: &ateapipb.ActorRef{Atespace: demoAtespace, Name: actorID}, }); err != nil { t.Fatalf("failed to delete Actor: %v", err) } // Verify deletion if _, err := clients.SubstrateAPI.GetActor(ctx, &ateapipb.GetActorRequest{ - Atespace: demoAtespace, - ActorId: actorID, + ActorRef: &ateapipb.ActorRef{Atespace: demoAtespace, Name: actorID}, }); err == nil { t.Fatalf("expected actor %q to be deleted, but it still exists", actorID) } @@ -619,8 +606,7 @@ func waitForActorStatus(ctx context.Context, t *testing.T, clients *e2e.Clients, deadline := time.Now().Add(timeout) for time.Now().Before(deadline) { resp, err := clients.SubstrateAPI.GetActor(ctx, &ateapipb.GetActorRequest{ - Atespace: demoAtespace, - ActorId: actorID, + ActorRef: &ateapipb.ActorRef{Atespace: demoAtespace, Name: actorID}, }) if err == nil { if resp.GetActor().GetStatus() == expectedStatus { diff --git a/internal/e2e/suites/identity/identity_test.go b/internal/e2e/suites/identity/identity_test.go index 48d78c048..5f22dfc5f 100644 --- a/internal/e2e/suites/identity/identity_test.go +++ b/internal/e2e/suites/identity/identity_test.go @@ -162,8 +162,7 @@ func createAndResumeActor(t *testing.T, ctx context.Context, clients *e2e.Client // CreateActor requires the atespace to exist first. _, _ = clients.SubstrateAPI.CreateAtespace(ctx, &ateapipb.CreateAtespaceRequest{Name: probeNamespace}) if _, err := clients.SubstrateAPI.CreateActor(ctx, &ateapipb.CreateActorRequest{ - Atespace: probeNamespace, - ActorId: id, + ActorRef: &ateapipb.ActorRef{Atespace: probeNamespace, Name: id}, ActorTemplateNamespace: probeNamespace, ActorTemplateName: probeTemplate, }); err != nil { @@ -171,12 +170,12 @@ func createAndResumeActor(t *testing.T, ctx context.Context, clients *e2e.Client } t.Cleanup(func() { // DeleteActor requires the actor to be suspended. - _, _ = clients.SubstrateAPI.SuspendActor(ctx, &ateapipb.SuspendActorRequest{Atespace: probeNamespace, ActorId: id}) - _, _ = clients.SubstrateAPI.DeleteActor(ctx, &ateapipb.DeleteActorRequest{Atespace: probeNamespace, ActorId: id}) + _, _ = clients.SubstrateAPI.SuspendActor(ctx, &ateapipb.SuspendActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: probeNamespace, Name: id}}) + _, _ = clients.SubstrateAPI.DeleteActor(ctx, &ateapipb.DeleteActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: probeNamespace, Name: id}}) }) // Resume from the golden snapshot (the restore path, not --boot). - if _, err := clients.SubstrateAPI.ResumeActor(ctx, &ateapipb.ResumeActorRequest{Atespace: probeNamespace, ActorId: id}); err != nil { + if _, err := clients.SubstrateAPI.ResumeActor(ctx, &ateapipb.ResumeActorRequest{ActorRef: &ateapipb.ActorRef{Atespace: probeNamespace, Name: id}}); err != nil { t.Fatalf("ResumeActor %q: %v", id, err) } } diff --git a/pkg/proto/ateapipb/ateapi.pb.go b/pkg/proto/ateapipb/ateapi.pb.go index 6e4387a92..99037bab6 100644 --- a/pkg/proto/ateapipb/ateapi.pb.go +++ b/pkg/proto/ateapipb/ateapi.pb.go @@ -585,6 +585,59 @@ func (x *Atespace) GetName() string { return "" } +// ActorRef identifies an actor: a name is only unique within its atespace. +type ActorRef struct { + state protoimpl.MessageState `protogen:"open.v1"` + Atespace string `protobuf:"bytes,1,opt,name=atespace,proto3" json:"atespace,omitempty"` + Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ActorRef) Reset() { + *x = ActorRef{} + mi := &file_ateapi_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ActorRef) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ActorRef) ProtoMessage() {} + +func (x *ActorRef) ProtoReflect() protoreflect.Message { + mi := &file_ateapi_proto_msgTypes[6] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use ActorRef.ProtoReflect.Descriptor instead. +func (*ActorRef) Descriptor() ([]byte, []int) { + return file_ateapi_proto_rawDescGZIP(), []int{6} +} + +func (x *ActorRef) GetAtespace() string { + if x != nil { + return x.Atespace + } + return "" +} + +func (x *ActorRef) GetName() string { + if x != nil { + return x.Name + } + return "" +} + type CreateAtespaceRequest struct { state protoimpl.MessageState `protogen:"open.v1"` Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` @@ -594,7 +647,7 @@ type CreateAtespaceRequest struct { func (x *CreateAtespaceRequest) Reset() { *x = CreateAtespaceRequest{} - mi := &file_ateapi_proto_msgTypes[6] + mi := &file_ateapi_proto_msgTypes[7] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -606,7 +659,7 @@ func (x *CreateAtespaceRequest) String() string { func (*CreateAtespaceRequest) ProtoMessage() {} func (x *CreateAtespaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[6] + mi := &file_ateapi_proto_msgTypes[7] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -619,7 +672,7 @@ func (x *CreateAtespaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateAtespaceRequest.ProtoReflect.Descriptor instead. func (*CreateAtespaceRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{6} + return file_ateapi_proto_rawDescGZIP(), []int{7} } func (x *CreateAtespaceRequest) GetName() string { @@ -638,7 +691,7 @@ type CreateAtespaceResponse struct { func (x *CreateAtespaceResponse) Reset() { *x = CreateAtespaceResponse{} - mi := &file_ateapi_proto_msgTypes[7] + mi := &file_ateapi_proto_msgTypes[8] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -650,7 +703,7 @@ func (x *CreateAtespaceResponse) String() string { func (*CreateAtespaceResponse) ProtoMessage() {} func (x *CreateAtespaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[7] + mi := &file_ateapi_proto_msgTypes[8] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -663,7 +716,7 @@ func (x *CreateAtespaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateAtespaceResponse.ProtoReflect.Descriptor instead. func (*CreateAtespaceResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{7} + return file_ateapi_proto_rawDescGZIP(), []int{8} } func (x *CreateAtespaceResponse) GetAtespace() *Atespace { @@ -682,7 +735,7 @@ type GetAtespaceRequest struct { func (x *GetAtespaceRequest) Reset() { *x = GetAtespaceRequest{} - mi := &file_ateapi_proto_msgTypes[8] + mi := &file_ateapi_proto_msgTypes[9] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -694,7 +747,7 @@ func (x *GetAtespaceRequest) String() string { func (*GetAtespaceRequest) ProtoMessage() {} func (x *GetAtespaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[8] + mi := &file_ateapi_proto_msgTypes[9] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -707,7 +760,7 @@ func (x *GetAtespaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetAtespaceRequest.ProtoReflect.Descriptor instead. func (*GetAtespaceRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{8} + return file_ateapi_proto_rawDescGZIP(), []int{9} } func (x *GetAtespaceRequest) GetName() string { @@ -726,7 +779,7 @@ type GetAtespaceResponse struct { func (x *GetAtespaceResponse) Reset() { *x = GetAtespaceResponse{} - mi := &file_ateapi_proto_msgTypes[9] + mi := &file_ateapi_proto_msgTypes[10] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -738,7 +791,7 @@ func (x *GetAtespaceResponse) String() string { func (*GetAtespaceResponse) ProtoMessage() {} func (x *GetAtespaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[9] + mi := &file_ateapi_proto_msgTypes[10] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -751,7 +804,7 @@ func (x *GetAtespaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetAtespaceResponse.ProtoReflect.Descriptor instead. func (*GetAtespaceResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{9} + return file_ateapi_proto_rawDescGZIP(), []int{10} } func (x *GetAtespaceResponse) GetAtespace() *Atespace { @@ -769,7 +822,7 @@ type ListAtespacesRequest struct { func (x *ListAtespacesRequest) Reset() { *x = ListAtespacesRequest{} - mi := &file_ateapi_proto_msgTypes[10] + mi := &file_ateapi_proto_msgTypes[11] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -781,7 +834,7 @@ func (x *ListAtespacesRequest) String() string { func (*ListAtespacesRequest) ProtoMessage() {} func (x *ListAtespacesRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[10] + mi := &file_ateapi_proto_msgTypes[11] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -794,7 +847,7 @@ func (x *ListAtespacesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListAtespacesRequest.ProtoReflect.Descriptor instead. func (*ListAtespacesRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{10} + return file_ateapi_proto_rawDescGZIP(), []int{11} } type ListAtespacesResponse struct { @@ -806,7 +859,7 @@ type ListAtespacesResponse struct { func (x *ListAtespacesResponse) Reset() { *x = ListAtespacesResponse{} - mi := &file_ateapi_proto_msgTypes[11] + mi := &file_ateapi_proto_msgTypes[12] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -818,7 +871,7 @@ func (x *ListAtespacesResponse) String() string { func (*ListAtespacesResponse) ProtoMessage() {} func (x *ListAtespacesResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[11] + mi := &file_ateapi_proto_msgTypes[12] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -831,7 +884,7 @@ func (x *ListAtespacesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListAtespacesResponse.ProtoReflect.Descriptor instead. func (*ListAtespacesResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{11} + return file_ateapi_proto_rawDescGZIP(), []int{12} } func (x *ListAtespacesResponse) GetAtespaces() []*Atespace { @@ -850,7 +903,7 @@ type DeleteAtespaceRequest struct { func (x *DeleteAtespaceRequest) Reset() { *x = DeleteAtespaceRequest{} - mi := &file_ateapi_proto_msgTypes[12] + mi := &file_ateapi_proto_msgTypes[13] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -862,7 +915,7 @@ func (x *DeleteAtespaceRequest) String() string { func (*DeleteAtespaceRequest) ProtoMessage() {} func (x *DeleteAtespaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[12] + mi := &file_ateapi_proto_msgTypes[13] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -875,7 +928,7 @@ func (x *DeleteAtespaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteAtespaceRequest.ProtoReflect.Descriptor instead. func (*DeleteAtespaceRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{12} + return file_ateapi_proto_rawDescGZIP(), []int{13} } func (x *DeleteAtespaceRequest) GetName() string { @@ -893,7 +946,7 @@ type DeleteAtespaceResponse struct { func (x *DeleteAtespaceResponse) Reset() { *x = DeleteAtespaceResponse{} - mi := &file_ateapi_proto_msgTypes[13] + mi := &file_ateapi_proto_msgTypes[14] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -905,7 +958,7 @@ func (x *DeleteAtespaceResponse) String() string { func (*DeleteAtespaceResponse) ProtoMessage() {} func (x *DeleteAtespaceResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[13] + mi := &file_ateapi_proto_msgTypes[14] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -918,20 +971,19 @@ func (x *DeleteAtespaceResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteAtespaceResponse.ProtoReflect.Descriptor instead. func (*DeleteAtespaceResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{13} + return file_ateapi_proto_rawDescGZIP(), []int{14} } type GetActorRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - ActorId string `protobuf:"bytes,1,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"` - Atespace string `protobuf:"bytes,2,opt,name=atespace,proto3" json:"atespace,omitempty"` + ActorRef *ActorRef `protobuf:"bytes,1,opt,name=actor_ref,json=actorRef,proto3" json:"actor_ref,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } func (x *GetActorRequest) Reset() { *x = GetActorRequest{} - mi := &file_ateapi_proto_msgTypes[14] + mi := &file_ateapi_proto_msgTypes[15] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -943,7 +995,7 @@ func (x *GetActorRequest) String() string { func (*GetActorRequest) ProtoMessage() {} func (x *GetActorRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[14] + mi := &file_ateapi_proto_msgTypes[15] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -956,21 +1008,14 @@ func (x *GetActorRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetActorRequest.ProtoReflect.Descriptor instead. func (*GetActorRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{14} + return file_ateapi_proto_rawDescGZIP(), []int{15} } -func (x *GetActorRequest) GetActorId() string { +func (x *GetActorRequest) GetActorRef() *ActorRef { if x != nil { - return x.ActorId + return x.ActorRef } - return "" -} - -func (x *GetActorRequest) GetAtespace() string { - if x != nil { - return x.Atespace - } - return "" + return nil } type GetActorResponse struct { @@ -982,7 +1027,7 @@ type GetActorResponse struct { func (x *GetActorResponse) Reset() { *x = GetActorResponse{} - mi := &file_ateapi_proto_msgTypes[15] + mi := &file_ateapi_proto_msgTypes[16] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -994,7 +1039,7 @@ func (x *GetActorResponse) String() string { func (*GetActorResponse) ProtoMessage() {} func (x *GetActorResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[15] + mi := &file_ateapi_proto_msgTypes[16] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1007,7 +1052,7 @@ func (x *GetActorResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use GetActorResponse.ProtoReflect.Descriptor instead. func (*GetActorResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{15} + return file_ateapi_proto_rawDescGZIP(), []int{16} } func (x *GetActorResponse) GetActor() *Actor { @@ -1020,8 +1065,8 @@ func (x *GetActorResponse) GetActor() *Actor { // Request to create a new Actor. type CreateActorRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // The custom identifier for the new Actor. Must be a valid DNS-1123 label. - ActorId string `protobuf:"bytes,1,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"` + // The new actor's atespace and actor_id (actor_id must be a valid DNS-1123 label). + ActorRef *ActorRef `protobuf:"bytes,1,opt,name=actor_ref,json=actorRef,proto3" json:"actor_ref,omitempty"` // The namespace of the ActorTemplate to derive from. ActorTemplateNamespace string `protobuf:"bytes,2,opt,name=actor_template_namespace,json=actorTemplateNamespace,proto3" json:"actor_template_namespace,omitempty"` // The name of the ActorTemplate to derive from. @@ -1029,15 +1074,13 @@ type CreateActorRequest struct { // worker_selector sets the actor's placement constraint at creation time. // If empty, the actor matches any pool admitted by the template's selector. WorkerSelector *Selector `protobuf:"bytes,4,opt,name=worker_selector,json=workerSelector,proto3" json:"worker_selector,omitempty"` - // The atespace to create the actor into. - Atespace string `protobuf:"bytes,5,opt,name=atespace,proto3" json:"atespace,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *CreateActorRequest) Reset() { *x = CreateActorRequest{} - mi := &file_ateapi_proto_msgTypes[16] + mi := &file_ateapi_proto_msgTypes[17] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1049,7 +1092,7 @@ func (x *CreateActorRequest) String() string { func (*CreateActorRequest) ProtoMessage() {} func (x *CreateActorRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[16] + mi := &file_ateapi_proto_msgTypes[17] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1062,14 +1105,14 @@ func (x *CreateActorRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateActorRequest.ProtoReflect.Descriptor instead. func (*CreateActorRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{16} + return file_ateapi_proto_rawDescGZIP(), []int{17} } -func (x *CreateActorRequest) GetActorId() string { +func (x *CreateActorRequest) GetActorRef() *ActorRef { if x != nil { - return x.ActorId + return x.ActorRef } - return "" + return nil } func (x *CreateActorRequest) GetActorTemplateNamespace() string { @@ -1093,13 +1136,6 @@ func (x *CreateActorRequest) GetWorkerSelector() *Selector { return nil } -func (x *CreateActorRequest) GetAtespace() string { - if x != nil { - return x.Atespace - } - return "" -} - type CreateActorResponse struct { state protoimpl.MessageState `protogen:"open.v1"` Actor *Actor `protobuf:"bytes,1,opt,name=actor,proto3" json:"actor,omitempty"` @@ -1109,7 +1145,7 @@ type CreateActorResponse struct { func (x *CreateActorResponse) Reset() { *x = CreateActorResponse{} - mi := &file_ateapi_proto_msgTypes[17] + mi := &file_ateapi_proto_msgTypes[18] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1121,7 +1157,7 @@ func (x *CreateActorResponse) String() string { func (*CreateActorResponse) ProtoMessage() {} func (x *CreateActorResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[17] + mi := &file_ateapi_proto_msgTypes[18] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1134,7 +1170,7 @@ func (x *CreateActorResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateActorResponse.ProtoReflect.Descriptor instead. func (*CreateActorResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{17} + return file_ateapi_proto_rawDescGZIP(), []int{18} } func (x *CreateActorResponse) GetActor() *Actor { @@ -1148,20 +1184,18 @@ func (x *CreateActorResponse) GetActor() *Actor { // May be called regardless of the actor's current status. // Changes take effect on the next ResumeActor call. type UpdateActorRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - ActorId string `protobuf:"bytes,1,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"` + state protoimpl.MessageState `protogen:"open.v1"` + ActorRef *ActorRef `protobuf:"bytes,1,opt,name=actor_ref,json=actorRef,proto3" json:"actor_ref,omitempty"` // worker_selector replaces the actor's current placement constraint. // Takes effect on the next ResumeActor call. WorkerSelector *Selector `protobuf:"bytes,2,opt,name=worker_selector,json=workerSelector,proto3" json:"worker_selector,omitempty"` - // The atespace the actor lives in. - Atespace string `protobuf:"bytes,3,opt,name=atespace,proto3" json:"atespace,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *UpdateActorRequest) Reset() { *x = UpdateActorRequest{} - mi := &file_ateapi_proto_msgTypes[18] + mi := &file_ateapi_proto_msgTypes[19] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1173,7 +1207,7 @@ func (x *UpdateActorRequest) String() string { func (*UpdateActorRequest) ProtoMessage() {} func (x *UpdateActorRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[18] + mi := &file_ateapi_proto_msgTypes[19] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1186,14 +1220,14 @@ func (x *UpdateActorRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateActorRequest.ProtoReflect.Descriptor instead. func (*UpdateActorRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{18} + return file_ateapi_proto_rawDescGZIP(), []int{19} } -func (x *UpdateActorRequest) GetActorId() string { +func (x *UpdateActorRequest) GetActorRef() *ActorRef { if x != nil { - return x.ActorId + return x.ActorRef } - return "" + return nil } func (x *UpdateActorRequest) GetWorkerSelector() *Selector { @@ -1203,13 +1237,6 @@ func (x *UpdateActorRequest) GetWorkerSelector() *Selector { return nil } -func (x *UpdateActorRequest) GetAtespace() string { - if x != nil { - return x.Atespace - } - return "" -} - type UpdateActorResponse struct { state protoimpl.MessageState `protogen:"open.v1"` Actor *Actor `protobuf:"bytes,1,opt,name=actor,proto3" json:"actor,omitempty"` @@ -1219,7 +1246,7 @@ type UpdateActorResponse struct { func (x *UpdateActorResponse) Reset() { *x = UpdateActorResponse{} - mi := &file_ateapi_proto_msgTypes[19] + mi := &file_ateapi_proto_msgTypes[20] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1231,7 +1258,7 @@ func (x *UpdateActorResponse) String() string { func (*UpdateActorResponse) ProtoMessage() {} func (x *UpdateActorResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[19] + mi := &file_ateapi_proto_msgTypes[20] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1244,7 +1271,7 @@ func (x *UpdateActorResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateActorResponse.ProtoReflect.Descriptor instead. func (*UpdateActorResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{19} + return file_ateapi_proto_rawDescGZIP(), []int{20} } func (x *UpdateActorResponse) GetActor() *Actor { @@ -1256,15 +1283,14 @@ func (x *UpdateActorResponse) GetActor() *Actor { type SuspendActorRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - ActorId string `protobuf:"bytes,1,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"` - Atespace string `protobuf:"bytes,2,opt,name=atespace,proto3" json:"atespace,omitempty"` + ActorRef *ActorRef `protobuf:"bytes,1,opt,name=actor_ref,json=actorRef,proto3" json:"actor_ref,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } func (x *SuspendActorRequest) Reset() { *x = SuspendActorRequest{} - mi := &file_ateapi_proto_msgTypes[20] + mi := &file_ateapi_proto_msgTypes[21] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1276,7 +1302,7 @@ func (x *SuspendActorRequest) String() string { func (*SuspendActorRequest) ProtoMessage() {} func (x *SuspendActorRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[20] + mi := &file_ateapi_proto_msgTypes[21] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1289,21 +1315,14 @@ func (x *SuspendActorRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SuspendActorRequest.ProtoReflect.Descriptor instead. func (*SuspendActorRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{20} + return file_ateapi_proto_rawDescGZIP(), []int{21} } -func (x *SuspendActorRequest) GetActorId() string { +func (x *SuspendActorRequest) GetActorRef() *ActorRef { if x != nil { - return x.ActorId + return x.ActorRef } - return "" -} - -func (x *SuspendActorRequest) GetAtespace() string { - if x != nil { - return x.Atespace - } - return "" + return nil } type SuspendActorResponse struct { @@ -1315,7 +1334,7 @@ type SuspendActorResponse struct { func (x *SuspendActorResponse) Reset() { *x = SuspendActorResponse{} - mi := &file_ateapi_proto_msgTypes[21] + mi := &file_ateapi_proto_msgTypes[22] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1327,7 +1346,7 @@ func (x *SuspendActorResponse) String() string { func (*SuspendActorResponse) ProtoMessage() {} func (x *SuspendActorResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[21] + mi := &file_ateapi_proto_msgTypes[22] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1340,7 +1359,7 @@ func (x *SuspendActorResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SuspendActorResponse.ProtoReflect.Descriptor instead. func (*SuspendActorResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{21} + return file_ateapi_proto_rawDescGZIP(), []int{22} } func (x *SuspendActorResponse) GetActor() *Actor { @@ -1352,15 +1371,14 @@ func (x *SuspendActorResponse) GetActor() *Actor { type PauseActorRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - ActorId string `protobuf:"bytes,1,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"` - Atespace string `protobuf:"bytes,2,opt,name=atespace,proto3" json:"atespace,omitempty"` + ActorRef *ActorRef `protobuf:"bytes,1,opt,name=actor_ref,json=actorRef,proto3" json:"actor_ref,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } func (x *PauseActorRequest) Reset() { *x = PauseActorRequest{} - mi := &file_ateapi_proto_msgTypes[22] + mi := &file_ateapi_proto_msgTypes[23] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1372,7 +1390,7 @@ func (x *PauseActorRequest) String() string { func (*PauseActorRequest) ProtoMessage() {} func (x *PauseActorRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[22] + mi := &file_ateapi_proto_msgTypes[23] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1385,21 +1403,14 @@ func (x *PauseActorRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use PauseActorRequest.ProtoReflect.Descriptor instead. func (*PauseActorRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{22} + return file_ateapi_proto_rawDescGZIP(), []int{23} } -func (x *PauseActorRequest) GetActorId() string { +func (x *PauseActorRequest) GetActorRef() *ActorRef { if x != nil { - return x.ActorId + return x.ActorRef } - return "" -} - -func (x *PauseActorRequest) GetAtespace() string { - if x != nil { - return x.Atespace - } - return "" + return nil } type PauseActorResponse struct { @@ -1411,7 +1422,7 @@ type PauseActorResponse struct { func (x *PauseActorResponse) Reset() { *x = PauseActorResponse{} - mi := &file_ateapi_proto_msgTypes[23] + mi := &file_ateapi_proto_msgTypes[24] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1423,7 +1434,7 @@ func (x *PauseActorResponse) String() string { func (*PauseActorResponse) ProtoMessage() {} func (x *PauseActorResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[23] + mi := &file_ateapi_proto_msgTypes[24] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1436,7 +1447,7 @@ func (x *PauseActorResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use PauseActorResponse.ProtoReflect.Descriptor instead. func (*PauseActorResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{23} + return file_ateapi_proto_rawDescGZIP(), []int{24} } func (x *PauseActorResponse) GetActor() *Actor { @@ -1447,18 +1458,17 @@ func (x *PauseActorResponse) GetActor() *Actor { } type ResumeActorRequest struct { - state protoimpl.MessageState `protogen:"open.v1"` - ActorId string `protobuf:"bytes,1,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"` + state protoimpl.MessageState `protogen:"open.v1"` + ActorRef *ActorRef `protobuf:"bytes,1,opt,name=actor_ref,json=actorRef,proto3" json:"actor_ref,omitempty"` // If true, skip golden snapshot and boot the workload from scratch. - Boot bool `protobuf:"varint,2,opt,name=boot,proto3" json:"boot,omitempty"` - Atespace string `protobuf:"bytes,3,opt,name=atespace,proto3" json:"atespace,omitempty"` + Boot bool `protobuf:"varint,2,opt,name=boot,proto3" json:"boot,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } func (x *ResumeActorRequest) Reset() { *x = ResumeActorRequest{} - mi := &file_ateapi_proto_msgTypes[24] + mi := &file_ateapi_proto_msgTypes[25] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1470,7 +1480,7 @@ func (x *ResumeActorRequest) String() string { func (*ResumeActorRequest) ProtoMessage() {} func (x *ResumeActorRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[24] + mi := &file_ateapi_proto_msgTypes[25] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1483,14 +1493,14 @@ func (x *ResumeActorRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ResumeActorRequest.ProtoReflect.Descriptor instead. func (*ResumeActorRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{24} + return file_ateapi_proto_rawDescGZIP(), []int{25} } -func (x *ResumeActorRequest) GetActorId() string { +func (x *ResumeActorRequest) GetActorRef() *ActorRef { if x != nil { - return x.ActorId + return x.ActorRef } - return "" + return nil } func (x *ResumeActorRequest) GetBoot() bool { @@ -1500,13 +1510,6 @@ func (x *ResumeActorRequest) GetBoot() bool { return false } -func (x *ResumeActorRequest) GetAtespace() string { - if x != nil { - return x.Atespace - } - return "" -} - type ResumeActorResponse struct { state protoimpl.MessageState `protogen:"open.v1"` Actor *Actor `protobuf:"bytes,1,opt,name=actor,proto3" json:"actor,omitempty"` @@ -1516,7 +1519,7 @@ type ResumeActorResponse struct { func (x *ResumeActorResponse) Reset() { *x = ResumeActorResponse{} - mi := &file_ateapi_proto_msgTypes[25] + mi := &file_ateapi_proto_msgTypes[26] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1528,7 +1531,7 @@ func (x *ResumeActorResponse) String() string { func (*ResumeActorResponse) ProtoMessage() {} func (x *ResumeActorResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[25] + mi := &file_ateapi_proto_msgTypes[26] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1541,7 +1544,7 @@ func (x *ResumeActorResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ResumeActorResponse.ProtoReflect.Descriptor instead. func (*ResumeActorResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{25} + return file_ateapi_proto_rawDescGZIP(), []int{26} } func (x *ResumeActorResponse) GetActor() *Actor { @@ -1553,15 +1556,14 @@ func (x *ResumeActorResponse) GetActor() *Actor { type DeleteActorRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - ActorId string `protobuf:"bytes,1,opt,name=actor_id,json=actorId,proto3" json:"actor_id,omitempty"` - Atespace string `protobuf:"bytes,2,opt,name=atespace,proto3" json:"atespace,omitempty"` + ActorRef *ActorRef `protobuf:"bytes,1,opt,name=actor_ref,json=actorRef,proto3" json:"actor_ref,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } func (x *DeleteActorRequest) Reset() { *x = DeleteActorRequest{} - mi := &file_ateapi_proto_msgTypes[26] + mi := &file_ateapi_proto_msgTypes[27] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1573,7 +1575,7 @@ func (x *DeleteActorRequest) String() string { func (*DeleteActorRequest) ProtoMessage() {} func (x *DeleteActorRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[26] + mi := &file_ateapi_proto_msgTypes[27] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1586,21 +1588,14 @@ func (x *DeleteActorRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteActorRequest.ProtoReflect.Descriptor instead. func (*DeleteActorRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{26} + return file_ateapi_proto_rawDescGZIP(), []int{27} } -func (x *DeleteActorRequest) GetActorId() string { +func (x *DeleteActorRequest) GetActorRef() *ActorRef { if x != nil { - return x.ActorId + return x.ActorRef } - return "" -} - -func (x *DeleteActorRequest) GetAtespace() string { - if x != nil { - return x.Atespace - } - return "" + return nil } type DeleteActorResponse struct { @@ -1611,7 +1606,7 @@ type DeleteActorResponse struct { func (x *DeleteActorResponse) Reset() { *x = DeleteActorResponse{} - mi := &file_ateapi_proto_msgTypes[27] + mi := &file_ateapi_proto_msgTypes[28] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1623,7 +1618,7 @@ func (x *DeleteActorResponse) String() string { func (*DeleteActorResponse) ProtoMessage() {} func (x *DeleteActorResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[27] + mi := &file_ateapi_proto_msgTypes[28] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1636,7 +1631,7 @@ func (x *DeleteActorResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteActorResponse.ProtoReflect.Descriptor instead. func (*DeleteActorResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{27} + return file_ateapi_proto_rawDescGZIP(), []int{28} } type ListWorkersRequest struct { @@ -1647,7 +1642,7 @@ type ListWorkersRequest struct { func (x *ListWorkersRequest) Reset() { *x = ListWorkersRequest{} - mi := &file_ateapi_proto_msgTypes[28] + mi := &file_ateapi_proto_msgTypes[29] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1659,7 +1654,7 @@ func (x *ListWorkersRequest) String() string { func (*ListWorkersRequest) ProtoMessage() {} func (x *ListWorkersRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[28] + mi := &file_ateapi_proto_msgTypes[29] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1672,7 +1667,7 @@ func (x *ListWorkersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkersRequest.ProtoReflect.Descriptor instead. func (*ListWorkersRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{28} + return file_ateapi_proto_rawDescGZIP(), []int{29} } type ListWorkersResponse struct { @@ -1684,7 +1679,7 @@ type ListWorkersResponse struct { func (x *ListWorkersResponse) Reset() { *x = ListWorkersResponse{} - mi := &file_ateapi_proto_msgTypes[29] + mi := &file_ateapi_proto_msgTypes[30] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1696,7 +1691,7 @@ func (x *ListWorkersResponse) String() string { func (*ListWorkersResponse) ProtoMessage() {} func (x *ListWorkersResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[29] + mi := &file_ateapi_proto_msgTypes[30] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1709,7 +1704,7 @@ func (x *ListWorkersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkersResponse.ProtoReflect.Descriptor instead. func (*ListWorkersResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{29} + return file_ateapi_proto_rawDescGZIP(), []int{30} } func (x *ListWorkersResponse) GetWorkers() []*Worker { @@ -1738,7 +1733,7 @@ type ListActorsRequest struct { func (x *ListActorsRequest) Reset() { *x = ListActorsRequest{} - mi := &file_ateapi_proto_msgTypes[30] + mi := &file_ateapi_proto_msgTypes[31] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1750,7 +1745,7 @@ func (x *ListActorsRequest) String() string { func (*ListActorsRequest) ProtoMessage() {} func (x *ListActorsRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[30] + mi := &file_ateapi_proto_msgTypes[31] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1763,7 +1758,7 @@ func (x *ListActorsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListActorsRequest.ProtoReflect.Descriptor instead. func (*ListActorsRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{30} + return file_ateapi_proto_rawDescGZIP(), []int{31} } func (x *ListActorsRequest) GetPageSize() int32 { @@ -1801,7 +1796,7 @@ type ListActorsResponse struct { func (x *ListActorsResponse) Reset() { *x = ListActorsResponse{} - mi := &file_ateapi_proto_msgTypes[31] + mi := &file_ateapi_proto_msgTypes[32] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1813,7 +1808,7 @@ func (x *ListActorsResponse) String() string { func (*ListActorsResponse) ProtoMessage() {} func (x *ListActorsResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[31] + mi := &file_ateapi_proto_msgTypes[32] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1826,7 +1821,7 @@ func (x *ListActorsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListActorsResponse.ProtoReflect.Descriptor instead. func (*ListActorsResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{31} + return file_ateapi_proto_rawDescGZIP(), []int{32} } func (x *ListActorsResponse) GetActors() []*Actor { @@ -1864,7 +1859,7 @@ type Worker struct { func (x *Worker) Reset() { *x = Worker{} - mi := &file_ateapi_proto_msgTypes[32] + mi := &file_ateapi_proto_msgTypes[33] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1876,7 +1871,7 @@ func (x *Worker) String() string { func (*Worker) ProtoMessage() {} func (x *Worker) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[32] + mi := &file_ateapi_proto_msgTypes[33] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1889,7 +1884,7 @@ func (x *Worker) ProtoReflect() protoreflect.Message { // Deprecated: Use Worker.ProtoReflect.Descriptor instead. func (*Worker) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{32} + return file_ateapi_proto_rawDescGZIP(), []int{33} } func (x *Worker) GetWorkerNamespace() string { @@ -1977,7 +1972,7 @@ type DebugClearRequest struct { func (x *DebugClearRequest) Reset() { *x = DebugClearRequest{} - mi := &file_ateapi_proto_msgTypes[33] + mi := &file_ateapi_proto_msgTypes[34] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1989,7 +1984,7 @@ func (x *DebugClearRequest) String() string { func (*DebugClearRequest) ProtoMessage() {} func (x *DebugClearRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[33] + mi := &file_ateapi_proto_msgTypes[34] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2002,7 +1997,7 @@ func (x *DebugClearRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DebugClearRequest.ProtoReflect.Descriptor instead. func (*DebugClearRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{33} + return file_ateapi_proto_rawDescGZIP(), []int{34} } type DebugClearResponse struct { @@ -2013,7 +2008,7 @@ type DebugClearResponse struct { func (x *DebugClearResponse) Reset() { *x = DebugClearResponse{} - mi := &file_ateapi_proto_msgTypes[34] + mi := &file_ateapi_proto_msgTypes[35] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2025,7 +2020,7 @@ func (x *DebugClearResponse) String() string { func (*DebugClearResponse) ProtoMessage() {} func (x *DebugClearResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[34] + mi := &file_ateapi_proto_msgTypes[35] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2038,7 +2033,7 @@ func (x *DebugClearResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DebugClearResponse.ProtoReflect.Descriptor instead. func (*DebugClearResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{34} + return file_ateapi_proto_rawDescGZIP(), []int{35} } type MintJWTRequest struct { @@ -2053,7 +2048,7 @@ type MintJWTRequest struct { func (x *MintJWTRequest) Reset() { *x = MintJWTRequest{} - mi := &file_ateapi_proto_msgTypes[35] + mi := &file_ateapi_proto_msgTypes[36] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2065,7 +2060,7 @@ func (x *MintJWTRequest) String() string { func (*MintJWTRequest) ProtoMessage() {} func (x *MintJWTRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[35] + mi := &file_ateapi_proto_msgTypes[36] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2078,7 +2073,7 @@ func (x *MintJWTRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MintJWTRequest.ProtoReflect.Descriptor instead. func (*MintJWTRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{35} + return file_ateapi_proto_rawDescGZIP(), []int{36} } func (x *MintJWTRequest) GetAudience() []string { @@ -2138,7 +2133,7 @@ type MintJWTResponse struct { func (x *MintJWTResponse) Reset() { *x = MintJWTResponse{} - mi := &file_ateapi_proto_msgTypes[36] + mi := &file_ateapi_proto_msgTypes[37] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2150,7 +2145,7 @@ func (x *MintJWTResponse) String() string { func (*MintJWTResponse) ProtoMessage() {} func (x *MintJWTResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[36] + mi := &file_ateapi_proto_msgTypes[37] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2163,7 +2158,7 @@ func (x *MintJWTResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MintJWTResponse.ProtoReflect.Descriptor instead. func (*MintJWTResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{36} + return file_ateapi_proto_rawDescGZIP(), []int{37} } func (x *MintJWTResponse) GetSessionJwt() string { @@ -2188,7 +2183,7 @@ type MintCertRequest struct { func (x *MintCertRequest) Reset() { *x = MintCertRequest{} - mi := &file_ateapi_proto_msgTypes[37] + mi := &file_ateapi_proto_msgTypes[38] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2200,7 +2195,7 @@ func (x *MintCertRequest) String() string { func (*MintCertRequest) ProtoMessage() {} func (x *MintCertRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[37] + mi := &file_ateapi_proto_msgTypes[38] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2213,7 +2208,7 @@ func (x *MintCertRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MintCertRequest.ProtoReflect.Descriptor instead. func (*MintCertRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{37} + return file_ateapi_proto_rawDescGZIP(), []int{38} } func (x *MintCertRequest) GetAppId() string { @@ -2256,7 +2251,7 @@ type MintCertResponse struct { func (x *MintCertResponse) Reset() { *x = MintCertResponse{} - mi := &file_ateapi_proto_msgTypes[38] + mi := &file_ateapi_proto_msgTypes[39] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2268,7 +2263,7 @@ func (x *MintCertResponse) String() string { func (*MintCertResponse) ProtoMessage() {} func (x *MintCertResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[38] + mi := &file_ateapi_proto_msgTypes[39] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2281,7 +2276,7 @@ func (x *MintCertResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MintCertResponse.ProtoReflect.Descriptor instead. func (*MintCertResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{38} + return file_ateapi_proto_rawDescGZIP(), []int{39} } func (x *MintCertResponse) GetSessionCertificates() [][]byte { @@ -2338,7 +2333,10 @@ const file_ateapi_proto_rawDesc = "" + "\rSTATUS_PAUSED\x10\x06J\x04\b\t\x10\n" + "\"\x1e\n" + "\bAtespace\x12\x12\n" + - "\x04name\x18\x01 \x01(\tR\x04name\"+\n" + + "\x04name\x18\x01 \x01(\tR\x04name\":\n" + + "\bActorRef\x12\x1a\n" + + "\batespace\x18\x01 \x01(\tR\batespace\x12\x12\n" + + "\x04name\x18\x02 \x01(\tR\x04name\"+\n" + "\x15CreateAtespaceRequest\x12\x12\n" + "\x04name\x18\x01 \x01(\tR\x04name\"F\n" + "\x16CreateAtespaceResponse\x12,\n" + @@ -2352,45 +2350,38 @@ const file_ateapi_proto_rawDesc = "" + "\tatespaces\x18\x01 \x03(\v2\x10.ateapi.AtespaceR\tatespaces\"+\n" + "\x15DeleteAtespaceRequest\x12\x12\n" + "\x04name\x18\x01 \x01(\tR\x04name\"\x18\n" + - "\x16DeleteAtespaceResponse\"H\n" + - "\x0fGetActorRequest\x12\x19\n" + - "\bactor_id\x18\x01 \x01(\tR\aactorId\x12\x1a\n" + - "\batespace\x18\x02 \x01(\tR\batespace\"7\n" + + "\x16DeleteAtespaceResponse\"@\n" + + "\x0fGetActorRequest\x12-\n" + + "\tactor_ref\x18\x01 \x01(\v2\x10.ateapi.ActorRefR\bactorRef\"7\n" + "\x10GetActorResponse\x12#\n" + - "\x05actor\x18\x01 \x01(\v2\r.ateapi.ActorR\x05actor\"\xf0\x01\n" + - "\x12CreateActorRequest\x12\x19\n" + - "\bactor_id\x18\x01 \x01(\tR\aactorId\x128\n" + + "\x05actor\x18\x01 \x01(\v2\r.ateapi.ActorR\x05actor\"\xe8\x01\n" + + "\x12CreateActorRequest\x12-\n" + + "\tactor_ref\x18\x01 \x01(\v2\x10.ateapi.ActorRefR\bactorRef\x128\n" + "\x18actor_template_namespace\x18\x02 \x01(\tR\x16actorTemplateNamespace\x12.\n" + "\x13actor_template_name\x18\x03 \x01(\tR\x11actorTemplateName\x129\n" + - "\x0fworker_selector\x18\x04 \x01(\v2\x10.ateapi.SelectorR\x0eworkerSelector\x12\x1a\n" + - "\batespace\x18\x05 \x01(\tR\batespace\":\n" + + "\x0fworker_selector\x18\x04 \x01(\v2\x10.ateapi.SelectorR\x0eworkerSelector\":\n" + "\x13CreateActorResponse\x12#\n" + - "\x05actor\x18\x01 \x01(\v2\r.ateapi.ActorR\x05actor\"\x86\x01\n" + - "\x12UpdateActorRequest\x12\x19\n" + - "\bactor_id\x18\x01 \x01(\tR\aactorId\x129\n" + - "\x0fworker_selector\x18\x02 \x01(\v2\x10.ateapi.SelectorR\x0eworkerSelector\x12\x1a\n" + - "\batespace\x18\x03 \x01(\tR\batespace\":\n" + + "\x05actor\x18\x01 \x01(\v2\r.ateapi.ActorR\x05actor\"~\n" + + "\x12UpdateActorRequest\x12-\n" + + "\tactor_ref\x18\x01 \x01(\v2\x10.ateapi.ActorRefR\bactorRef\x129\n" + + "\x0fworker_selector\x18\x02 \x01(\v2\x10.ateapi.SelectorR\x0eworkerSelector\":\n" + "\x13UpdateActorResponse\x12#\n" + - "\x05actor\x18\x01 \x01(\v2\r.ateapi.ActorR\x05actor\"L\n" + - "\x13SuspendActorRequest\x12\x19\n" + - "\bactor_id\x18\x01 \x01(\tR\aactorId\x12\x1a\n" + - "\batespace\x18\x02 \x01(\tR\batespace\";\n" + + "\x05actor\x18\x01 \x01(\v2\r.ateapi.ActorR\x05actor\"D\n" + + "\x13SuspendActorRequest\x12-\n" + + "\tactor_ref\x18\x01 \x01(\v2\x10.ateapi.ActorRefR\bactorRef\";\n" + "\x14SuspendActorResponse\x12#\n" + - "\x05actor\x18\x01 \x01(\v2\r.ateapi.ActorR\x05actor\"J\n" + - "\x11PauseActorRequest\x12\x19\n" + - "\bactor_id\x18\x01 \x01(\tR\aactorId\x12\x1a\n" + - "\batespace\x18\x02 \x01(\tR\batespace\"9\n" + + "\x05actor\x18\x01 \x01(\v2\r.ateapi.ActorR\x05actor\"B\n" + + "\x11PauseActorRequest\x12-\n" + + "\tactor_ref\x18\x01 \x01(\v2\x10.ateapi.ActorRefR\bactorRef\"9\n" + "\x12PauseActorResponse\x12#\n" + - "\x05actor\x18\x01 \x01(\v2\r.ateapi.ActorR\x05actor\"_\n" + - "\x12ResumeActorRequest\x12\x19\n" + - "\bactor_id\x18\x01 \x01(\tR\aactorId\x12\x12\n" + - "\x04boot\x18\x02 \x01(\bR\x04boot\x12\x1a\n" + - "\batespace\x18\x03 \x01(\tR\batespace\":\n" + + "\x05actor\x18\x01 \x01(\v2\r.ateapi.ActorR\x05actor\"W\n" + + "\x12ResumeActorRequest\x12-\n" + + "\tactor_ref\x18\x01 \x01(\v2\x10.ateapi.ActorRefR\bactorRef\x12\x12\n" + + "\x04boot\x18\x02 \x01(\bR\x04boot\":\n" + "\x13ResumeActorResponse\x12#\n" + - "\x05actor\x18\x01 \x01(\v2\r.ateapi.ActorR\x05actor\"K\n" + - "\x12DeleteActorRequest\x12\x19\n" + - "\bactor_id\x18\x01 \x01(\tR\aactorId\x12\x1a\n" + - "\batespace\x18\x02 \x01(\tR\batespace\"\x15\n" + + "\x05actor\x18\x01 \x01(\v2\r.ateapi.ActorR\x05actor\"C\n" + + "\x12DeleteActorRequest\x12-\n" + + "\tactor_ref\x18\x01 \x01(\v2\x10.ateapi.ActorRefR\bactorRef\"\x15\n" + "\x13DeleteActorResponse\"\x14\n" + "\x12ListWorkersRequest\"?\n" + "\x13ListWorkersResponse\x12(\n" + @@ -2476,7 +2467,7 @@ func file_ateapi_proto_rawDescGZIP() []byte { } var file_ateapi_proto_enumTypes = make([]protoimpl.EnumInfo, 2) -var file_ateapi_proto_msgTypes = make([]protoimpl.MessageInfo, 40) +var file_ateapi_proto_msgTypes = make([]protoimpl.MessageInfo, 41) var file_ateapi_proto_goTypes = []any{ (SnapshotType)(0), // 0: ateapi.SnapshotType (Actor_Status)(0), // 1: ateapi.Actor.Status @@ -2486,99 +2477,107 @@ var file_ateapi_proto_goTypes = []any{ (*Selector)(nil), // 5: ateapi.Selector (*Actor)(nil), // 6: ateapi.Actor (*Atespace)(nil), // 7: ateapi.Atespace - (*CreateAtespaceRequest)(nil), // 8: ateapi.CreateAtespaceRequest - (*CreateAtespaceResponse)(nil), // 9: ateapi.CreateAtespaceResponse - (*GetAtespaceRequest)(nil), // 10: ateapi.GetAtespaceRequest - (*GetAtespaceResponse)(nil), // 11: ateapi.GetAtespaceResponse - (*ListAtespacesRequest)(nil), // 12: ateapi.ListAtespacesRequest - (*ListAtespacesResponse)(nil), // 13: ateapi.ListAtespacesResponse - (*DeleteAtespaceRequest)(nil), // 14: ateapi.DeleteAtespaceRequest - (*DeleteAtespaceResponse)(nil), // 15: ateapi.DeleteAtespaceResponse - (*GetActorRequest)(nil), // 16: ateapi.GetActorRequest - (*GetActorResponse)(nil), // 17: ateapi.GetActorResponse - (*CreateActorRequest)(nil), // 18: ateapi.CreateActorRequest - (*CreateActorResponse)(nil), // 19: ateapi.CreateActorResponse - (*UpdateActorRequest)(nil), // 20: ateapi.UpdateActorRequest - (*UpdateActorResponse)(nil), // 21: ateapi.UpdateActorResponse - (*SuspendActorRequest)(nil), // 22: ateapi.SuspendActorRequest - (*SuspendActorResponse)(nil), // 23: ateapi.SuspendActorResponse - (*PauseActorRequest)(nil), // 24: ateapi.PauseActorRequest - (*PauseActorResponse)(nil), // 25: ateapi.PauseActorResponse - (*ResumeActorRequest)(nil), // 26: ateapi.ResumeActorRequest - (*ResumeActorResponse)(nil), // 27: ateapi.ResumeActorResponse - (*DeleteActorRequest)(nil), // 28: ateapi.DeleteActorRequest - (*DeleteActorResponse)(nil), // 29: ateapi.DeleteActorResponse - (*ListWorkersRequest)(nil), // 30: ateapi.ListWorkersRequest - (*ListWorkersResponse)(nil), // 31: ateapi.ListWorkersResponse - (*ListActorsRequest)(nil), // 32: ateapi.ListActorsRequest - (*ListActorsResponse)(nil), // 33: ateapi.ListActorsResponse - (*Worker)(nil), // 34: ateapi.Worker - (*DebugClearRequest)(nil), // 35: ateapi.DebugClearRequest - (*DebugClearResponse)(nil), // 36: ateapi.DebugClearResponse - (*MintJWTRequest)(nil), // 37: ateapi.MintJWTRequest - (*MintJWTResponse)(nil), // 38: ateapi.MintJWTResponse - (*MintCertRequest)(nil), // 39: ateapi.MintCertRequest - (*MintCertResponse)(nil), // 40: ateapi.MintCertResponse - nil, // 41: ateapi.Selector.MatchLabelsEntry + (*ActorRef)(nil), // 8: ateapi.ActorRef + (*CreateAtespaceRequest)(nil), // 9: ateapi.CreateAtespaceRequest + (*CreateAtespaceResponse)(nil), // 10: ateapi.CreateAtespaceResponse + (*GetAtespaceRequest)(nil), // 11: ateapi.GetAtespaceRequest + (*GetAtespaceResponse)(nil), // 12: ateapi.GetAtespaceResponse + (*ListAtespacesRequest)(nil), // 13: ateapi.ListAtespacesRequest + (*ListAtespacesResponse)(nil), // 14: ateapi.ListAtespacesResponse + (*DeleteAtespaceRequest)(nil), // 15: ateapi.DeleteAtespaceRequest + (*DeleteAtespaceResponse)(nil), // 16: ateapi.DeleteAtespaceResponse + (*GetActorRequest)(nil), // 17: ateapi.GetActorRequest + (*GetActorResponse)(nil), // 18: ateapi.GetActorResponse + (*CreateActorRequest)(nil), // 19: ateapi.CreateActorRequest + (*CreateActorResponse)(nil), // 20: ateapi.CreateActorResponse + (*UpdateActorRequest)(nil), // 21: ateapi.UpdateActorRequest + (*UpdateActorResponse)(nil), // 22: ateapi.UpdateActorResponse + (*SuspendActorRequest)(nil), // 23: ateapi.SuspendActorRequest + (*SuspendActorResponse)(nil), // 24: ateapi.SuspendActorResponse + (*PauseActorRequest)(nil), // 25: ateapi.PauseActorRequest + (*PauseActorResponse)(nil), // 26: ateapi.PauseActorResponse + (*ResumeActorRequest)(nil), // 27: ateapi.ResumeActorRequest + (*ResumeActorResponse)(nil), // 28: ateapi.ResumeActorResponse + (*DeleteActorRequest)(nil), // 29: ateapi.DeleteActorRequest + (*DeleteActorResponse)(nil), // 30: ateapi.DeleteActorResponse + (*ListWorkersRequest)(nil), // 31: ateapi.ListWorkersRequest + (*ListWorkersResponse)(nil), // 32: ateapi.ListWorkersResponse + (*ListActorsRequest)(nil), // 33: ateapi.ListActorsRequest + (*ListActorsResponse)(nil), // 34: ateapi.ListActorsResponse + (*Worker)(nil), // 35: ateapi.Worker + (*DebugClearRequest)(nil), // 36: ateapi.DebugClearRequest + (*DebugClearResponse)(nil), // 37: ateapi.DebugClearResponse + (*MintJWTRequest)(nil), // 38: ateapi.MintJWTRequest + (*MintJWTResponse)(nil), // 39: ateapi.MintJWTResponse + (*MintCertRequest)(nil), // 40: ateapi.MintCertRequest + (*MintCertResponse)(nil), // 41: ateapi.MintCertResponse + nil, // 42: ateapi.Selector.MatchLabelsEntry } var file_ateapi_proto_depIdxs = []int32{ 0, // 0: ateapi.SnapshotInfo.type:type_name -> ateapi.SnapshotType 2, // 1: ateapi.SnapshotInfo.external:type_name -> ateapi.ExternalSnapshotInfo 3, // 2: ateapi.SnapshotInfo.local:type_name -> ateapi.LocalSnapshotInfo - 41, // 3: ateapi.Selector.match_labels:type_name -> ateapi.Selector.MatchLabelsEntry + 42, // 3: ateapi.Selector.match_labels:type_name -> ateapi.Selector.MatchLabelsEntry 1, // 4: ateapi.Actor.status:type_name -> ateapi.Actor.Status 4, // 5: ateapi.Actor.latest_snapshot_info:type_name -> ateapi.SnapshotInfo 5, // 6: ateapi.Actor.worker_selector:type_name -> ateapi.Selector 7, // 7: ateapi.CreateAtespaceResponse.atespace:type_name -> ateapi.Atespace 7, // 8: ateapi.GetAtespaceResponse.atespace:type_name -> ateapi.Atespace 7, // 9: ateapi.ListAtespacesResponse.atespaces:type_name -> ateapi.Atespace - 6, // 10: ateapi.GetActorResponse.actor:type_name -> ateapi.Actor - 5, // 11: ateapi.CreateActorRequest.worker_selector:type_name -> ateapi.Selector - 6, // 12: ateapi.CreateActorResponse.actor:type_name -> ateapi.Actor - 5, // 13: ateapi.UpdateActorRequest.worker_selector:type_name -> ateapi.Selector - 6, // 14: ateapi.UpdateActorResponse.actor:type_name -> ateapi.Actor - 6, // 15: ateapi.SuspendActorResponse.actor:type_name -> ateapi.Actor - 6, // 16: ateapi.PauseActorResponse.actor:type_name -> ateapi.Actor - 6, // 17: ateapi.ResumeActorResponse.actor:type_name -> ateapi.Actor - 34, // 18: ateapi.ListWorkersResponse.workers:type_name -> ateapi.Worker - 6, // 19: ateapi.ListActorsResponse.actors:type_name -> ateapi.Actor - 16, // 20: ateapi.Control.GetActor:input_type -> ateapi.GetActorRequest - 18, // 21: ateapi.Control.CreateActor:input_type -> ateapi.CreateActorRequest - 20, // 22: ateapi.Control.UpdateActor:input_type -> ateapi.UpdateActorRequest - 22, // 23: ateapi.Control.SuspendActor:input_type -> ateapi.SuspendActorRequest - 24, // 24: ateapi.Control.PauseActor:input_type -> ateapi.PauseActorRequest - 26, // 25: ateapi.Control.ResumeActor:input_type -> ateapi.ResumeActorRequest - 28, // 26: ateapi.Control.DeleteActor:input_type -> ateapi.DeleteActorRequest - 30, // 27: ateapi.Control.ListWorkers:input_type -> ateapi.ListWorkersRequest - 32, // 28: ateapi.Control.ListActors:input_type -> ateapi.ListActorsRequest - 8, // 29: ateapi.Control.CreateAtespace:input_type -> ateapi.CreateAtespaceRequest - 10, // 30: ateapi.Control.GetAtespace:input_type -> ateapi.GetAtespaceRequest - 12, // 31: ateapi.Control.ListAtespaces:input_type -> ateapi.ListAtespacesRequest - 14, // 32: ateapi.Control.DeleteAtespace:input_type -> ateapi.DeleteAtespaceRequest - 35, // 33: ateapi.Control.DebugClear:input_type -> ateapi.DebugClearRequest - 37, // 34: ateapi.SessionIdentity.MintJWT:input_type -> ateapi.MintJWTRequest - 39, // 35: ateapi.SessionIdentity.MintCert:input_type -> ateapi.MintCertRequest - 17, // 36: ateapi.Control.GetActor:output_type -> ateapi.GetActorResponse - 19, // 37: ateapi.Control.CreateActor:output_type -> ateapi.CreateActorResponse - 21, // 38: ateapi.Control.UpdateActor:output_type -> ateapi.UpdateActorResponse - 23, // 39: ateapi.Control.SuspendActor:output_type -> ateapi.SuspendActorResponse - 25, // 40: ateapi.Control.PauseActor:output_type -> ateapi.PauseActorResponse - 27, // 41: ateapi.Control.ResumeActor:output_type -> ateapi.ResumeActorResponse - 29, // 42: ateapi.Control.DeleteActor:output_type -> ateapi.DeleteActorResponse - 31, // 43: ateapi.Control.ListWorkers:output_type -> ateapi.ListWorkersResponse - 33, // 44: ateapi.Control.ListActors:output_type -> ateapi.ListActorsResponse - 9, // 45: ateapi.Control.CreateAtespace:output_type -> ateapi.CreateAtespaceResponse - 11, // 46: ateapi.Control.GetAtespace:output_type -> ateapi.GetAtespaceResponse - 13, // 47: ateapi.Control.ListAtespaces:output_type -> ateapi.ListAtespacesResponse - 15, // 48: ateapi.Control.DeleteAtespace:output_type -> ateapi.DeleteAtespaceResponse - 36, // 49: ateapi.Control.DebugClear:output_type -> ateapi.DebugClearResponse - 38, // 50: ateapi.SessionIdentity.MintJWT:output_type -> ateapi.MintJWTResponse - 40, // 51: ateapi.SessionIdentity.MintCert:output_type -> ateapi.MintCertResponse - 36, // [36:52] is the sub-list for method output_type - 20, // [20:36] is the sub-list for method input_type - 20, // [20:20] is the sub-list for extension type_name - 20, // [20:20] is the sub-list for extension extendee - 0, // [0:20] is the sub-list for field type_name + 8, // 10: ateapi.GetActorRequest.actor_ref:type_name -> ateapi.ActorRef + 6, // 11: ateapi.GetActorResponse.actor:type_name -> ateapi.Actor + 8, // 12: ateapi.CreateActorRequest.actor_ref:type_name -> ateapi.ActorRef + 5, // 13: ateapi.CreateActorRequest.worker_selector:type_name -> ateapi.Selector + 6, // 14: ateapi.CreateActorResponse.actor:type_name -> ateapi.Actor + 8, // 15: ateapi.UpdateActorRequest.actor_ref:type_name -> ateapi.ActorRef + 5, // 16: ateapi.UpdateActorRequest.worker_selector:type_name -> ateapi.Selector + 6, // 17: ateapi.UpdateActorResponse.actor:type_name -> ateapi.Actor + 8, // 18: ateapi.SuspendActorRequest.actor_ref:type_name -> ateapi.ActorRef + 6, // 19: ateapi.SuspendActorResponse.actor:type_name -> ateapi.Actor + 8, // 20: ateapi.PauseActorRequest.actor_ref:type_name -> ateapi.ActorRef + 6, // 21: ateapi.PauseActorResponse.actor:type_name -> ateapi.Actor + 8, // 22: ateapi.ResumeActorRequest.actor_ref:type_name -> ateapi.ActorRef + 6, // 23: ateapi.ResumeActorResponse.actor:type_name -> ateapi.Actor + 8, // 24: ateapi.DeleteActorRequest.actor_ref:type_name -> ateapi.ActorRef + 35, // 25: ateapi.ListWorkersResponse.workers:type_name -> ateapi.Worker + 6, // 26: ateapi.ListActorsResponse.actors:type_name -> ateapi.Actor + 17, // 27: ateapi.Control.GetActor:input_type -> ateapi.GetActorRequest + 19, // 28: ateapi.Control.CreateActor:input_type -> ateapi.CreateActorRequest + 21, // 29: ateapi.Control.UpdateActor:input_type -> ateapi.UpdateActorRequest + 23, // 30: ateapi.Control.SuspendActor:input_type -> ateapi.SuspendActorRequest + 25, // 31: ateapi.Control.PauseActor:input_type -> ateapi.PauseActorRequest + 27, // 32: ateapi.Control.ResumeActor:input_type -> ateapi.ResumeActorRequest + 29, // 33: ateapi.Control.DeleteActor:input_type -> ateapi.DeleteActorRequest + 31, // 34: ateapi.Control.ListWorkers:input_type -> ateapi.ListWorkersRequest + 33, // 35: ateapi.Control.ListActors:input_type -> ateapi.ListActorsRequest + 9, // 36: ateapi.Control.CreateAtespace:input_type -> ateapi.CreateAtespaceRequest + 11, // 37: ateapi.Control.GetAtespace:input_type -> ateapi.GetAtespaceRequest + 13, // 38: ateapi.Control.ListAtespaces:input_type -> ateapi.ListAtespacesRequest + 15, // 39: ateapi.Control.DeleteAtespace:input_type -> ateapi.DeleteAtespaceRequest + 36, // 40: ateapi.Control.DebugClear:input_type -> ateapi.DebugClearRequest + 38, // 41: ateapi.SessionIdentity.MintJWT:input_type -> ateapi.MintJWTRequest + 40, // 42: ateapi.SessionIdentity.MintCert:input_type -> ateapi.MintCertRequest + 18, // 43: ateapi.Control.GetActor:output_type -> ateapi.GetActorResponse + 20, // 44: ateapi.Control.CreateActor:output_type -> ateapi.CreateActorResponse + 22, // 45: ateapi.Control.UpdateActor:output_type -> ateapi.UpdateActorResponse + 24, // 46: ateapi.Control.SuspendActor:output_type -> ateapi.SuspendActorResponse + 26, // 47: ateapi.Control.PauseActor:output_type -> ateapi.PauseActorResponse + 28, // 48: ateapi.Control.ResumeActor:output_type -> ateapi.ResumeActorResponse + 30, // 49: ateapi.Control.DeleteActor:output_type -> ateapi.DeleteActorResponse + 32, // 50: ateapi.Control.ListWorkers:output_type -> ateapi.ListWorkersResponse + 34, // 51: ateapi.Control.ListActors:output_type -> ateapi.ListActorsResponse + 10, // 52: ateapi.Control.CreateAtespace:output_type -> ateapi.CreateAtespaceResponse + 12, // 53: ateapi.Control.GetAtespace:output_type -> ateapi.GetAtespaceResponse + 14, // 54: ateapi.Control.ListAtespaces:output_type -> ateapi.ListAtespacesResponse + 16, // 55: ateapi.Control.DeleteAtespace:output_type -> ateapi.DeleteAtespaceResponse + 37, // 56: ateapi.Control.DebugClear:output_type -> ateapi.DebugClearResponse + 39, // 57: ateapi.SessionIdentity.MintJWT:output_type -> ateapi.MintJWTResponse + 41, // 58: ateapi.SessionIdentity.MintCert:output_type -> ateapi.MintCertResponse + 43, // [43:59] is the sub-list for method output_type + 27, // [27:43] is the sub-list for method input_type + 27, // [27:27] is the sub-list for extension type_name + 27, // [27:27] is the sub-list for extension extendee + 0, // [0:27] is the sub-list for field type_name } func init() { file_ateapi_proto_init() } @@ -2596,7 +2595,7 @@ func file_ateapi_proto_init() { GoPackagePath: reflect.TypeOf(x{}).PkgPath(), RawDescriptor: unsafe.Slice(unsafe.StringData(file_ateapi_proto_rawDesc), len(file_ateapi_proto_rawDesc)), NumEnums: 2, - NumMessages: 40, + NumMessages: 41, NumExtensions: 0, NumServices: 2, }, diff --git a/pkg/proto/ateapipb/ateapi.proto b/pkg/proto/ateapipb/ateapi.proto index f4639bafa..7c0082a89 100644 --- a/pkg/proto/ateapipb/ateapi.proto +++ b/pkg/proto/ateapipb/ateapi.proto @@ -148,6 +148,12 @@ message Atespace { string name = 1; } +// ActorRef identifies an actor: a name is only unique within its atespace. +message ActorRef { + string atespace = 1; + string name = 2; +} + message CreateAtespaceRequest { string name = 1; } @@ -173,8 +179,7 @@ message DeleteAtespaceRequest { message DeleteAtespaceResponse {} message GetActorRequest { - string actor_id = 1; - string atespace = 2; + ActorRef actor_ref = 1; } message GetActorResponse { @@ -183,8 +188,8 @@ message GetActorResponse { // Request to create a new Actor. message CreateActorRequest { - // The custom identifier for the new Actor. Must be a valid DNS-1123 label. - string actor_id = 1; + // The new actor's atespace and actor_id (actor_id must be a valid DNS-1123 label). + ActorRef actor_ref = 1; // The namespace of the ActorTemplate to derive from. string actor_template_namespace = 2; @@ -195,9 +200,6 @@ message CreateActorRequest { // worker_selector sets the actor's placement constraint at creation time. // If empty, the actor matches any pool admitted by the template's selector. Selector worker_selector = 4; - - // The atespace to create the actor into. - string atespace = 5; } message CreateActorResponse { @@ -208,14 +210,11 @@ message CreateActorResponse { // May be called regardless of the actor's current status. // Changes take effect on the next ResumeActor call. message UpdateActorRequest { - string actor_id = 1; + ActorRef actor_ref = 1; // worker_selector replaces the actor's current placement constraint. // Takes effect on the next ResumeActor call. Selector worker_selector = 2; - - // The atespace the actor lives in. - string atespace = 3; } message UpdateActorResponse { @@ -223,8 +222,7 @@ message UpdateActorResponse { } message SuspendActorRequest { - string actor_id = 1; - string atespace = 2; + ActorRef actor_ref = 1; } message SuspendActorResponse { @@ -232,8 +230,7 @@ message SuspendActorResponse { } message PauseActorRequest { - string actor_id = 1; - string atespace = 2; + ActorRef actor_ref = 1; } message PauseActorResponse { @@ -241,11 +238,10 @@ message PauseActorResponse { } message ResumeActorRequest { - string actor_id = 1; + ActorRef actor_ref = 1; // If true, skip golden snapshot and boot the workload from scratch. bool boot = 2; - string atespace = 3; } message ResumeActorResponse { @@ -253,8 +249,7 @@ message ResumeActorResponse { } message DeleteActorRequest { - string actor_id = 1; - string atespace = 2; + ActorRef actor_ref = 1; } message DeleteActorResponse {}