diff --git a/cmd/ateapi/internal/apivalidation/actor.go b/cmd/ateapi/internal/apivalidation/actor.go index a77942fcd3..8f33e1ee2b 100644 --- a/cmd/ateapi/internal/apivalidation/actor.go +++ b/cmd/ateapi/internal/apivalidation/actor.go @@ -30,6 +30,16 @@ func ValidateCreateActorRequest(ctx context.Context, req *ateapipb.CreateActorRe return Validate_CreateActorRequest(ctx, op, nil, req, nil) } +func ValidateCustom_CreateActorRequest(_ context.Context, _ operation.Operation, p *field.Path, req, _ *ateapipb.CreateActorRequest) field.ErrorList { + policy := req.GetInitialEgressPolicy() + policyPath := p.Child("initial_egress_policy") + errs := validateEgressPolicyParentAtespace(req.GetActor().GetMetadata().GetAtespace(), policy, policyPath) + if policy != nil && len(policy.GetRules()) == 0 { + errs = append(errs, field.Required(policyPath.Child("rules"), "must contain at least one rule")) + } + return errs +} + func ValidateGetActorRequest(ctx context.Context, req *ateapipb.GetActorRequest) field.ErrorList { // Call the generated validation. op := MakeCreateOp(ctx) diff --git a/cmd/ateapi/internal/apivalidation/actor_template_test.go b/cmd/ateapi/internal/apivalidation/actor_template_test.go index ebbba44356..743597e4f6 100644 --- a/cmd/ateapi/internal/apivalidation/actor_template_test.go +++ b/cmd/ateapi/internal/apivalidation/actor_template_test.go @@ -35,6 +35,48 @@ func TestValidateCreateActorTemplateRequest(t *testing.T) { "valid", &ateapipb.CreateActorTemplateRequest{ActorTemplate: validActorTemplate()}, nil, + }, { + "valid golden egress rules", + &ateapipb.CreateActorTemplateRequest{ActorTemplate: validActorTemplate(func(tmpl *ateapipb.ActorTemplate) { + tmpl.GoldenEgressPolicy = &ateapipb.EgressPolicyTemplate{Rules: []*ateapipb.EgressRule{{Http: &ateapipb.HttpRule{Hostnames: []string{"api.example.com"}, Ports: &ateapipb.Ports{Numbers: []int32{80}}}}}} + })}, + nil, + }, { + "missing golden egress rules", + &ateapipb.CreateActorTemplateRequest{ActorTemplate: validActorTemplate(func(tmpl *ateapipb.ActorTemplate) { + tmpl.GoldenEgressPolicy = &ateapipb.EgressPolicyTemplate{} + })}, + field.ErrorList{field.Required(field.NewPath("actor_template", "golden_egress_policy", "rules"), "")}, + }, { + "empty golden egress rules", + &ateapipb.CreateActorTemplateRequest{ActorTemplate: validActorTemplate(func(tmpl *ateapipb.ActorTemplate) { + tmpl.GoldenEgressPolicy = &ateapipb.EgressPolicyTemplate{Rules: []*ateapipb.EgressRule{}} + })}, + field.ErrorList{field.Required(field.NewPath("actor_template", "golden_egress_policy", "rules"), "")}, + }, { + "invalid golden egress hostname", + &ateapipb.CreateActorTemplateRequest{ActorTemplate: validActorTemplate(func(tmpl *ateapipb.ActorTemplate) { + tmpl.GoldenEgressPolicy = &ateapipb.EgressPolicyTemplate{Rules: []*ateapipb.EgressRule{{Http: &ateapipb.HttpRule{Hostnames: []string{"bad/host"}, Ports: &ateapipb.Ports{Numbers: []int32{80}}}}}} + })}, + field.ErrorList{field.Invalid(field.NewPath("actor_template", "golden_egress_policy", "rules").Index(0).Child("http", "hostnames").Index(0), nil, "")}, + }, { + "golden egress rules tie across protocols", + &ateapipb.CreateActorTemplateRequest{ActorTemplate: validActorTemplate(func(tmpl *ateapipb.ActorTemplate) { + tmpl.GoldenEgressPolicy = &ateapipb.EgressPolicyTemplate{Rules: []*ateapipb.EgressRule{ + {Https: &ateapipb.HttpsRule{Hostnames: []string{"api.example.com"}, Ports: &ateapipb.Ports{Numbers: []int32{443}}}}, + {TlsPassthrough: &ateapipb.TlsPassthroughRule{Hostnames: []string{"api.example.com"}, Ports: &ateapipb.Ports{Numbers: []int32{443}}}}, + }} + })}, + field.ErrorList{field.Invalid(field.NewPath("actor_template", "golden_egress_policy", "rules").Index(1).Child("tls_passthrough", "hostnames").Index(0), nil, "")}, + }, { + "too many golden egress rules", + &ateapipb.CreateActorTemplateRequest{ActorTemplate: validActorTemplate(func(tmpl *ateapipb.ActorTemplate) { + tmpl.GoldenEgressPolicy = &ateapipb.EgressPolicyTemplate{} + for i := range 257 { + tmpl.GoldenEgressPolicy.Rules = append(tmpl.GoldenEgressPolicy.Rules, &ateapipb.EgressRule{Http: &ateapipb.HttpRule{Hostnames: []string{fmt.Sprintf("host-%d.example.com", i)}, Ports: &ateapipb.Ports{Numbers: []int32{80}}}}) + } + })}, + field.ErrorList{field.TooMany(field.NewPath("actor_template", "golden_egress_policy", "rules"), 257, 256).WithOrigin("maxItems")}, }, { "missing actor_template", &ateapipb.CreateActorTemplateRequest{}, @@ -209,7 +251,15 @@ func TestValidateCreateActorTemplateRequest(t *testing.T) { }} for _, tt := range tests { t.Run(tt.name, func(t *testing.T) { - assertValidateErr(t, ValidateCreateActorTemplateRequest(context.Background(), tt.req), tt.want) + want := tt.want + var wantWithPreview map[string]field.ErrorList + if tt.req.GetActorTemplate().GetGoldenEgressPolicy() != nil { + want = field.ErrorList{field.Forbidden(field.NewPath("actor_template", "golden_egress_policy"), "")} + wantWithPreview = map[string]field.ErrorList{"GoldenEgressPolicy": tt.want, "ALL": tt.want} + } + assertValidate(t, func() field.ErrorList { + return ValidateCreateActorTemplateRequest(context.Background(), tt.req) + }, want, wantWithPreview) }) } } diff --git a/cmd/ateapi/internal/apivalidation/actor_test.go b/cmd/ateapi/internal/apivalidation/actor_test.go index dea6ab5882..4eb659d102 100644 --- a/cmd/ateapi/internal/apivalidation/actor_test.go +++ b/cmd/ateapi/internal/apivalidation/actor_test.go @@ -43,6 +43,19 @@ func TestValidateCreateActorRequest(t *testing.T) { withActorTemplate := withActorActorTemplate withSourceTag := withActorSourceTag withWorkerSelector := withActorWorkerSelector + withInitialPolicy := func(mods ...func(*ateapipb.EgressPolicy)) func(*ateapipb.CreateActorRequest) { + return func(r *ateapipb.CreateActorRequest) { + r.InitialEgressPolicy = &ateapipb.EgressPolicy{ + Metadata: &ateapipb.ResourceMetadata{Atespace: "ns1", Name: "default"}, + Rules: []*ateapipb.EgressRule{{ + Https: &ateapipb.HttpsRule{Hostnames: []string{"api.example.com"}, Ports: &ateapipb.Ports{Numbers: []int32{443}}}, + }}, + } + for _, mod := range mods { + mod(r.InitialEgressPolicy) + } + } + } tests := []struct { name string @@ -52,6 +65,50 @@ func TestValidateCreateActorRequest(t *testing.T) { "valid", validReq(validActor()), nil, + }, { + "valid initial egress policy", + validReq(validActor(), withInitialPolicy()), + nil, + }, { + "initial policy without actor", + validReq(nil, withInitialPolicy()), + field.ErrorList{field.Required(field.NewPath("actor"), "")}, + }, { + "initial policy without actor metadata", + validReq(validActor(func(a *ateapipb.Actor) { a.Metadata = nil }), withInitialPolicy()), + field.ErrorList{field.Required(field.NewPath("actor", "metadata"), "")}, + }, { + "missing initial policy metadata", + validReq(validActor(), withInitialPolicy(func(p *ateapipb.EgressPolicy) { p.Metadata = nil })), + field.ErrorList{field.Required(field.NewPath("initial_egress_policy", "metadata"), "")}, + }, { + "missing initial policy atespace", + validReq(validActor(), withInitialPolicy(func(p *ateapipb.EgressPolicy) { p.Metadata.Atespace = "" })), + field.ErrorList{field.Required(field.NewPath("initial_egress_policy", "metadata", "atespace"), "")}, + }, { + "mismatched initial policy atespace", + validReq(validActor(), withInitialPolicy(func(p *ateapipb.EgressPolicy) { p.Metadata.Atespace = "other" })), + field.ErrorList{field.Invalid(field.NewPath("initial_egress_policy", "metadata", "atespace"), "other", "")}, + }, { + "missing initial policy name", + validReq(validActor(), withInitialPolicy(func(p *ateapipb.EgressPolicy) { p.Metadata.Name = "" })), + field.ErrorList{field.Required(field.NewPath("initial_egress_policy", "metadata", "name"), "")}, + }, { + "initial policy name must be default", + validReq(validActor(), withInitialPolicy(func(p *ateapipb.EgressPolicy) { p.Metadata.Name = "custom" })), + field.ErrorList{field.Invalid(field.NewPath("initial_egress_policy", "metadata", "name"), "custom", "").WithOrigin("custom=default")}, + }, { + "missing initial egress rules", + validReq(validActor(), withInitialPolicy(func(p *ateapipb.EgressPolicy) { p.Rules = nil })), + field.ErrorList{field.Required(field.NewPath("initial_egress_policy", "rules"), "")}, + }, { + "empty initial egress rules", + validReq(validActor(), withInitialPolicy(func(p *ateapipb.EgressPolicy) { p.Rules = []*ateapipb.EgressRule{} })), + field.ErrorList{field.Required(field.NewPath("initial_egress_policy", "rules"), "")}, + }, { + "invalid initial egress hostname", + validReq(validActor(), withInitialPolicy(func(p *ateapipb.EgressPolicy) { p.Rules[0].Https.Hostnames = []string{"bad/host"} })), + field.ErrorList{field.Invalid(field.NewPath("initial_egress_policy", "rules").Index(0).Child("https", "hostnames").Index(0), nil, "")}, }, { "valid with status", validReq(validActor(withStatus())), diff --git a/cmd/ateapi/internal/apivalidation/egress_policy.go b/cmd/ateapi/internal/apivalidation/egress_policy.go index c890c45179..b7142ae007 100644 --- a/cmd/ateapi/internal/apivalidation/egress_policy.go +++ b/cmd/ateapi/internal/apivalidation/egress_policy.go @@ -53,25 +53,24 @@ func ValidateEgressPolicyUpdate(ctx context.Context, p *field.Path, newVal, oldV } func ValidateCustom_CreateActorEgressPolicyRequest(_ context.Context, _ operation.Operation, p *field.Path, req, _ *ateapipb.CreateActorEgressPolicyRequest) field.ErrorList { - return validateEgressPolicyParentAtespace(req.GetActor(), req.GetEgressPolicy(), p) + return validateEgressPolicyParentAtespace(req.GetActor().GetAtespace(), req.GetEgressPolicy(), p.Child("egress_policy")) } func ValidateCustom_UpdateActorEgressPolicyRequest(_ context.Context, _ operation.Operation, p *field.Path, req, _ *ateapipb.UpdateActorEgressPolicyRequest) field.ErrorList { - return validateEgressPolicyParentAtespace(req.GetActor(), req.GetEgressPolicy(), p) + return validateEgressPolicyParentAtespace(req.GetActor().GetAtespace(), req.GetEgressPolicy(), p.Child("egress_policy")) } -func validateEgressPolicyParentAtespace(actor *ateapipb.ObjectRef, policy *ateapipb.EgressPolicy, p *field.Path) field.ErrorList { - if actor == nil || actor.Atespace == "" { +func validateEgressPolicyParentAtespace(actorAtespace string, policy *ateapipb.EgressPolicy, p *field.Path) field.ErrorList { + if actorAtespace == "" { return nil // regular DV will handle it } - actorAtespace := actor.GetAtespace() if policy == nil || policy.Metadata == nil || policy.Metadata.Atespace == "" { return nil // regular DV will handle it } policyAtespace := policy.GetMetadata().GetAtespace() if actorAtespace != policyAtespace { return field.ErrorList{ - field.Invalid(p.Child("egress_policy", "metadata", "atespace"), policyAtespace, "must match actor.atespace"), + field.Invalid(p.Child("metadata", "atespace"), policyAtespace, "must match the parent actor's atespace"), } } return nil @@ -126,6 +125,10 @@ func ValidateCustom_EgressPolicy_Rules(_ context.Context, _ operation.Operation, return errs } +func ValidateCustom_EgressPolicyTemplate_Rules(ctx context.Context, op operation.Operation, p *field.Path, rules, oldRules []*ateapipb.EgressRule) field.ErrorList { + return ValidateCustom_EgressPolicy_Rules(ctx, op, p, rules, oldRules) +} + // ruleMatchFields is what a rule matches on: the union member, its hostnames, // and its ports. Everything is empty for a rule that sets no member. func ruleMatchFields(rule *ateapipb.EgressRule) (member string, hostnames []string, ports *ateapipb.Ports) { diff --git a/cmd/ateapi/internal/apivalidation/egress_policy_test.go b/cmd/ateapi/internal/apivalidation/egress_policy_test.go index 89829a165b..8b8633e650 100644 --- a/cmd/ateapi/internal/apivalidation/egress_policy_test.go +++ b/cmd/ateapi/internal/apivalidation/egress_policy_test.go @@ -179,7 +179,7 @@ func TestValidateCreateActorEgressPolicyRequest(t *testing.T) { return r }(), want: field.ErrorList{ - field.Invalid(field.NewPath("egress_policy", "metadata", "atespace"), "other", "must match actor.atespace"), + field.Invalid(field.NewPath("egress_policy", "metadata", "atespace"), "other", "must match the parent actor's atespace"), }, }} for _, tc := range tests { @@ -319,7 +319,7 @@ func TestValidateUpdateActorEgressPolicyRequest(t *testing.T) { return r }(), want: field.ErrorList{ - field.Invalid(field.NewPath("egress_policy", "metadata", "atespace"), "other", "must match actor.atespace"), + field.Invalid(field.NewPath("egress_policy", "metadata", "atespace"), "other", "must match the parent actor's atespace"), }, }, { name: "invalid rule", diff --git a/cmd/ateapi/internal/apivalidation/zz_generated.validation.go b/cmd/ateapi/internal/apivalidation/zz_generated.validation.go index d6e8ce53b7..83b5c8d45e 100644 --- a/cmd/ateapi/internal/apivalidation/zz_generated.validation.go +++ b/cmd/ateapi/internal/apivalidation/zz_generated.validation.go @@ -1334,6 +1334,43 @@ func Validate_ActorTemplate( errs = append(errs, fn(fldPath.Child("status"), obj.Status, oldVal, oldObj != nil)...) } + { // field ateapipb.ActorTemplate.GoldenEgressPolicy + fn := func( + fldPath *field.Path, + obj, oldObj *ateapipb.EgressPolicyTemplate, + oldValueCorrelated bool) (errs field.ErrorList) { + // don't revalidate unchanged data + if oldValueCorrelated && op.Type == operation.Update { + if ateDeepEqual(obj, oldObj) { + return nil + } + } + // call field-attached validations + earlyReturn := false + if e := validate.IfOption(ctx, op, fldPath, obj, oldObj, "GoldenEgressPolicy", false, validate.ForbiddenPointer).MarkShortCircuit(); len(e) != 0 { + errs = append(errs, e...) + earlyReturn = true + } + if e := validate.IfOption(ctx, op, fldPath, obj, oldObj, "GoldenEgressPolicy", false, validate.OptionalPointer).MarkShortCircuit(); len(e) != 0 { + earlyReturn = true + } + if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkShortCircuit(); len(e) != 0 { + earlyReturn = true + } + if earlyReturn { + return // do not proceed + } + // call the type's validation function + errs = append(errs, Validate_EgressPolicyTemplate(ctx, op, fldPath, obj, oldObj)...) + return + } + oldVal := safe.Field(oldObj, + func(oldObj *ateapipb.ActorTemplate) *ateapipb.EgressPolicyTemplate { + return oldObj.GoldenEgressPolicy + }) + errs = append(errs, fn(fldPath.Child("golden_egress_policy"), obj.GoldenEgressPolicy, oldVal, oldObj != nil)...) + } + return errs } @@ -2121,6 +2158,11 @@ func Validate_CreateActorRequest( ctx context.Context, op operation.Operation, fldPath *field.Path, obj, oldObj *ateapipb.CreateActorRequest) (errs field.ErrorList) { + // custom validation + if e := ValidateCustom_CreateActorRequest(ctx, op, fldPath, obj, oldObj); len(e) != 0 { + errs = append(errs, e...) + } + { // field ateapipb.CreateActorRequest.Actor fn := func( fldPath *field.Path, @@ -2152,6 +2194,36 @@ func Validate_CreateActorRequest( errs = append(errs, fn(fldPath.Child("actor"), obj.Actor, oldVal, oldObj != nil)...) } + { // field ateapipb.CreateActorRequest.InitialEgressPolicy + fn := func( + fldPath *field.Path, + obj, oldObj *ateapipb.EgressPolicy, + oldValueCorrelated bool) (errs field.ErrorList) { + // don't revalidate unchanged data + if oldValueCorrelated && op.Type == operation.Update { + if ateDeepEqual(obj, oldObj) { + return nil + } + } + // call field-attached validations + earlyReturn := false + if e := validate.OptionalPointer(ctx, op, fldPath, obj, oldObj).MarkShortCircuit(); len(e) != 0 { + earlyReturn = true + } + if earlyReturn { + return // do not proceed + } + // call the type's validation function + errs = append(errs, Validate_EgressPolicy(ctx, op, fldPath, obj, oldObj)...) + return + } + oldVal := safe.Field(oldObj, + func(oldObj *ateapipb.CreateActorRequest) *ateapipb.EgressPolicy { + return oldObj.InitialEgressPolicy + }) + errs = append(errs, fn(fldPath.Child("initial_egress_policy"), obj.InitialEgressPolicy, oldVal, oldObj != nil)...) + } + return errs } @@ -3553,6 +3625,60 @@ func Validate_EgressPolicy( return errs } +// Validate_EgressPolicyTemplate validates an instance of EgressPolicyTemplate according +// to declarative validation rules in the API schema. +func Validate_EgressPolicyTemplate( + ctx context.Context, op operation.Operation, fldPath *field.Path, + obj, oldObj *ateapipb.EgressPolicyTemplate) (errs field.ErrorList) { + + { // field ateapipb.EgressPolicyTemplate.Rules + fn := func( + fldPath *field.Path, + obj, oldObj []*ateapipb.EgressRule, + oldValueCorrelated bool) (errs field.ErrorList) { + // don't revalidate unchanged data + if oldValueCorrelated && op.Type == operation.Update { + if ateDeepEqual(obj, oldObj) { + return nil + } + } + // call field-attached validations + earlyReturn := false + if e := validate.PtrSliceNoNils[ateapipb.EgressRule](ctx, op, fldPath, obj, oldObj).MarkShortCircuit(); len(e) != 0 { + errs = append(errs, e...) + earlyReturn = true + } + if e := validate.MaxItems(ctx, op, fldPath, obj, oldObj, 256).MarkShortCircuit(); len(e) != 0 { + errs = append(errs, e...) + earlyReturn = true + } + if e := validate.RequiredSlice(ctx, op, fldPath, obj, oldObj).MarkShortCircuit(); len(e) != 0 { + errs = append(errs, e...) + earlyReturn = true + } + if earlyReturn { + return // do not proceed + } + // custom validation + if e := ValidateCustom_EgressPolicyTemplate_Rules(ctx, op, fldPath, obj, oldObj); len(e) != 0 { + errs = append(errs, e...) + } + // iterate the list and call the type's validation function + if e := validate.EachPtrSliceVal(ctx, op, fldPath, obj, oldObj, nil, nil, Validate_EgressRule); len(e) != 0 { + errs = append(errs, e...) + } + return + } + oldVal := safe.Field(oldObj, + func(oldObj *ateapipb.EgressPolicyTemplate) []*ateapipb.EgressRule { + return oldObj.Rules + }) + errs = append(errs, fn(fldPath.Child("rules"), obj.Rules, oldVal, oldObj != nil)...) + } + + return errs +} + var unionMembershipFor_github_com_agent_substrate_substrate_pkg_proto_ateapipb_EgressRule_ = validate.NewUnionMembership(validate.NewUnionMember("http"), validate.NewUnionMember("https"), validate.NewUnionMember("tls_passthrough")) // Validate_EgressRule validates an instance of EgressRule according diff --git a/cmd/ateapi/internal/authz/interceptor_test.go b/cmd/ateapi/internal/authz/interceptor_test.go index f7bf2c4fb6..e831837285 100644 --- a/cmd/ateapi/internal/authz/interceptor_test.go +++ b/cmd/ateapi/internal/authz/interceptor_test.go @@ -376,6 +376,17 @@ func TestUnaryServerInterceptor_ActorAndTemplateChecks(t *testing.T) { createActor := func(template *ateapipb.ObjectRef) rpcCall { return rpcCall{ateapipb.Control_CreateActor_FullMethodName, &ateapipb.CreateActorRequest{Actor: actorWithTemplate(template)}} } + createActorWithPolicy := func(template *ateapipb.ObjectRef) rpcCall { + return rpcCall{ateapipb.Control_CreateActor_FullMethodName, &ateapipb.CreateActorRequest{ + Actor: actorWithTemplate(template), + InitialEgressPolicy: &ateapipb.EgressPolicy{ + Metadata: &ateapipb.ResourceMetadata{Atespace: actor.GetAtespace(), Name: "default"}, + Rules: []*ateapipb.EgressRule{{ + Https: &ateapipb.HttpsRule{Hostnames: []string{"api.example.com"}}, + }}, + }, + }} + } updateActor := func(template *ateapipb.ObjectRef) rpcCall { return rpcCall{ateapipb.Control_UpdateActor_FullMethodName, &ateapipb.UpdateActorRequest{Actor: actorWithTemplate(template)}} } @@ -410,6 +421,15 @@ func TestUnaryServerInterceptor_ActorAndTemplateChecks(t *testing.T) { {"shared viewer cannot create actor without editor on team-a", "shared-viewer", createActor(shared), codes.PermissionDenied}, {"global owner creates actor from any template", "global-owner", createActor(shared), codes.OK}, + // No actor row or parent tuple exists yet. Initial policy creation uses + // the new actor's contextual parent link to evaluate its permissions. + {"editor creates actor with initial policy", "editor", createActorWithPolicy(local), codes.OK}, + {"editor creates actor with initial policy from shared template", "editor-with-shared", createActorWithPolicy(shared), codes.OK}, + {"viewer cannot create actor with initial policy", "viewer", createActorWithPolicy(local), codes.PermissionDenied}, + {"shared viewer cannot set initial policy in another atespace", "shared-viewer", createActorWithPolicy(shared), codes.PermissionDenied}, + {"initial policy does not grant template access", "editor", createActorWithPolicy(shared), codes.PermissionDenied}, + {"bootstrap owner creates actor with initial policy", "bootstrap-owner", createActorWithPolicy(shared), codes.OK}, + // UpdateActor needs can_update on the actor and can_use_template on the template. {"editor updates actor on local template", "editor", updateActor(local), codes.OK}, {"viewer cannot update actor", "viewer", updateActor(local), codes.PermissionDenied}, diff --git a/cmd/ateapi/internal/authz/registry.go b/cmd/ateapi/internal/authz/registry.go index 65231d9e9c..7afe4a71fa 100644 --- a/cmd/ateapi/internal/authz/registry.go +++ b/cmd/ateapi/internal/authz/registry.go @@ -232,7 +232,12 @@ var defaultRPCPermissions = map[string]rpcRule{ templateChecks, templateErrs := onActorTemplate(RelationCanUseTemplate, r.GetActor().GetActorTemplate(), field.NewPath("actor", "actor_template")) checks, errs := both(actorChecks, actorErrs, templateChecks, templateErrs) tagChecks, tagErrs := onSourceTag(r.GetActor().GetSourceTag(), field.NewPath("actor", "source_tag")) - return both(checks, errs, tagChecks, tagErrs) + checks, errs = both(checks, errs, tagChecks, tagErrs) + if r.GetInitialEgressPolicy() != nil { + policyChecks, policyErrs := onActor(RelationCanCreateEgressPolicy, r.GetActor().GetMetadata(), field.NewPath("actor", "metadata")) + return both(checks, errs, policyChecks, policyErrs) + } + return checks, errs })), ateapipb.Control_GetActor_FullMethodName: rule(checksOf(func(r *ateapipb.GetActorRequest) ([]check, field.ErrorList) { return onActor(RelationCanGet, r.GetActor(), field.NewPath("actor")) diff --git a/cmd/ateapi/internal/authz/registry_test.go b/cmd/ateapi/internal/authz/registry_test.go index ce3f8ceaf6..49fb19d206 100644 --- a/cmd/ateapi/internal/authz/registry_test.go +++ b/cmd/ateapi/internal/authz/registry_test.go @@ -135,6 +135,37 @@ func TestDefaultRPCPermissions(t *testing.T) { {RelationCanUseTemplate, "actor_template:shared/tmpl"}, }, }, + { + name: "CreateActor with an initial policy also checks policy creation on the new actor", + fullMethod: ateapipb.Control_CreateActor_FullMethodName, + req: &ateapipb.CreateActorRequest{ + Actor: &ateapipb.Actor{Metadata: actorMeta, ActorTemplate: sharedTemplate}, + InitialEgressPolicy: &ateapipb.EgressPolicy{}, + }, + want: []check{ + {RelationCanCreateActor, "atespace:team-a"}, + {RelationCanUseTemplate, "actor_template:shared/tmpl"}, + {RelationCanCreateEgressPolicy, "actor:team-a/runner"}, + }, + }, + { + name: "CreateActor from a tag with an initial policy checks both permissions", + fullMethod: ateapipb.Control_CreateActor_FullMethodName, + req: &ateapipb.CreateActorRequest{ + Actor: &ateapipb.Actor{ + Metadata: actorMeta, + ActorTemplate: sharedTemplate, + SourceTag: &ateapipb.ObjectRef{Atespace: "team-b", Name: "v1"}, + }, + InitialEgressPolicy: &ateapipb.EgressPolicy{}, + }, + want: []check{ + {RelationCanCreateActor, "atespace:team-a"}, + {RelationCanUseTemplate, "actor_template:shared/tmpl"}, + {RelationCanUseTag, "tag:team-b/v1"}, + {RelationCanCreateEgressPolicy, "actor:team-a/runner"}, + }, + }, { name: "GetActor", fullMethod: ateapipb.Control_GetActor_FullMethodName, @@ -420,6 +451,24 @@ func TestDefaultRPCPermissions_MalformedIdentifierFailsClosed(t *testing.T) { req: &ateapipb.CreateActorRequest{}, wantField: "actor.metadata.atespace", }, + { + name: "CreateActor with an initial policy without an actor name", + fullMethod: ateapipb.Control_CreateActor_FullMethodName, + req: &ateapipb.CreateActorRequest{ + Actor: &ateapipb.Actor{ + Metadata: &ateapipb.ResourceMetadata{Atespace: "team-a"}, + ActorTemplate: &ateapipb.ObjectRef{Atespace: "shared", Name: "tmpl"}, + }, + InitialEgressPolicy: &ateapipb.EgressPolicy{}, + }, + wantField: "actor.metadata.name", + }, + { + name: "CreateActor with an initial policy without an actor", + fullMethod: ateapipb.Control_CreateActor_FullMethodName, + req: &ateapipb.CreateActorRequest{InitialEgressPolicy: &ateapipb.EgressPolicy{}}, + wantField: "actor.metadata.atespace", + }, { name: "CreateActor without a template", fullMethod: ateapipb.Control_CreateActor_FullMethodName, diff --git a/cmd/ateapi/internal/controlapi/actor.go b/cmd/ateapi/internal/controlapi/actor.go index b0591d18e0..b88442a4f7 100644 --- a/cmd/ateapi/internal/controlapi/actor.go +++ b/cmd/ateapi/internal/controlapi/actor.go @@ -52,6 +52,11 @@ func (s *RPCService) CreateActor(ctx context.Context, req *ateapipb.CreateActorR inActor.Status = nil defaults.Apply(inActor) } + policy := req.GetInitialEgressPolicy() + if policy != nil { + scrubResourceMetadataForCreate(policy.Metadata) + defaults.Apply(policy) + } // Validate the request, including the object within it. if errs := apivalidation.ValidateCreateActorRequest(ctx, req); len(errs) > 0 { @@ -71,13 +76,13 @@ func (s *RPCService) CreateActor(ctx context.Context, req *ateapipb.CreateActorR setSpanActorRefAttributes(ctx, resources.ActorRefFromActor(inActor)) // Handle the creation, including validation of the final stored object. - stored, err := s.impl.CreateActor(ctx, inActor) + stored, err := s.impl.CreateActor(ctx, inActor, policy) setSpanActorAttributes(ctx, stored) return stored, err } -func (s *ServiceImpl) CreateActor(ctx context.Context, inActor *ateapipb.Actor) (*ateapipb.Actor, error) { +func (s *ServiceImpl) CreateActor(ctx context.Context, inActor *ateapipb.Actor, policy *ateapipb.EgressPolicy) (*ateapipb.Actor, error) { // Check that the referenced ActorTemplate exists. // FIXME: This is not atomic and it is not a guarantee that the template // will still exist later. Checking it here produces a nice error UX, but @@ -158,7 +163,7 @@ func (s *ServiceImpl) CreateActor(ctx context.Context, inActor *ateapipb.Actor) } // Save the data in the storage layer. - stored, err := s.store.CreateActor(ctx, outActor) + stored, err := s.store.CreateActor(ctx, outActor, policy) if err != nil { if errors.Is(err, store.ErrAlreadyExists) { return nil, apierror.AlreadyExists("Actor %s already exists", name) diff --git a/cmd/ateapi/internal/controlapi/actor_test.go b/cmd/ateapi/internal/controlapi/actor_test.go index 479cb03204..a69b8099de 100644 --- a/cmd/ateapi/internal/controlapi/actor_test.go +++ b/cmd/ateapi/internal/controlapi/actor_test.go @@ -21,6 +21,7 @@ import ( "crypto/rand" "crypto/tls" "crypto/x509" + "errors" "fmt" "strings" "testing" @@ -677,7 +678,7 @@ func TestUpdateActor_DeleteRecreateRace(t *testing.T) { Metadata: &ateapipb.ResourceMetadata{Atespace: testAtespace, Name: testActorID}, ActorTemplate: &ateapipb.ObjectRef{Atespace: "ns1", Name: "tmpl1"}, Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_SUSPENDED}, - }) + }, nil) if err != nil { t.Fatalf("racing writer: recreate CreateActor: %v", err) } @@ -842,6 +843,7 @@ func TestCreateActor_GoldenTagDefault(t *testing.T) { } if _, err := persistence.UpdateActorTemplate(ctx, resources.ActorTemplateRefFromActorTemplate(tmpl), store.PreconditionFrom(tmpl), func(db *ateapipb.ActorTemplate) error { db.Status = &ateapipb.ActorTemplateStatus{GoldenSnapshotStatus: &ateapipb.GoldenSnapshotStatus{GoldenTag: ref}} + db.GoldenEgressPolicy = &ateapipb.EgressPolicyTemplate{Rules: []*ateapipb.EgressRule{{Https: &ateapipb.HttpsRule{Hostnames: []string{"init.example.com"}, Ports: &ateapipb.Ports{Numbers: []int32{443}}}}}} return nil }); err != nil { t.Fatal(err) @@ -856,7 +858,7 @@ func TestCreateActor_GoldenTagDefault(t *testing.T) { actor.SourceTag = &ateapipb.ObjectRef{Atespace: ref.Atespace, Name: "explicit"} } svc := &ServiceImpl{store: persistence} - created, err := svc.CreateActor(ctx, actor) + created, err := svc.CreateActor(ctx, actor, nil) if apierror.Code(err) != wantCode { t.Fatalf("CreateActor = %v, want %v", err, wantCode) } @@ -867,6 +869,9 @@ func TestCreateActor_GoldenTagDefault(t *testing.T) { if gotSnap.GetDurableSnapshot().GetObject().GetSnapshotUri() != tagDurableSnapshotURI(tag, ateapipb.SnapshotStorageStatus_SNAPSHOT_STORAGE_STATUS_COMPLETED) || gotSnap.GetActorTemplateUid() != tmpl.GetMetadata().GetUid() { t.Fatalf("incorrect initial status: %v", created.GetStatus()) } + if _, err := persistence.GetEgressPolicy(ctx, resources.ActorRefFromActor(created)); !errors.Is(err, store.ErrNotFound) { + t.Fatalf("actor restored from a tag inherited golden policy: %v, want NotFound", err) + } if scenario == "own snapshot" { uri, err := resources.NewActorSnapshotURI(tmpl.GetSnapshotConfig().GetStorageLocation(), "team-a", created.GetMetadata().GetUid(), "snapshot") if err != nil { diff --git a/cmd/ateapi/internal/controlapi/egress_policy_test.go b/cmd/ateapi/internal/controlapi/egress_policy_test.go index 90f7777ade..aeb03c758a 100644 --- a/cmd/ateapi/internal/controlapi/egress_policy_test.go +++ b/cmd/ateapi/internal/controlapi/egress_policy_test.go @@ -38,7 +38,7 @@ func TestActorEgressPolicy(t *testing.T) { _, err := persistence.CreateActor(t.Context(), &ateapipb.Actor{ Metadata: &ateapipb.ResourceMetadata{Atespace: testAtespace, Name: "egress-actor"}, Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_RUNNING}, - }) + }, nil) if err != nil { t.Fatal(err) } diff --git a/cmd/ateapi/internal/controlapi/functionaltest/actor_template_test.go b/cmd/ateapi/internal/controlapi/functionaltest/actor_template_test.go index 2ff8dbdd28..76168358a1 100644 --- a/cmd/ateapi/internal/controlapi/functionaltest/actor_template_test.go +++ b/cmd/ateapi/internal/controlapi/functionaltest/actor_template_test.go @@ -24,6 +24,7 @@ import ( "github.com/agent-substrate/substrate/internal/preview" "github.com/agent-substrate/substrate/internal/resources" "google.golang.org/grpc/status" + "google.golang.org/protobuf/proto" "k8s.io/apimachinery/pkg/util/wait" "github.com/agent-substrate/substrate/pkg/proto/ateapipb" @@ -445,3 +446,64 @@ func TestCreateActorTemplate_ExternalVolumesPreview(t *testing.T) { }) } } + +func TestCreateActorTemplate_GoldenEgressPolicyPreview(t *testing.T) { + tc := setupPreviewTest(t, namespaceForTest("ns-template-golden-egress-preview")) + t.Cleanup(tc.cleanup) + base := createTemplateWithSelector(t, tc, "base", nil) + + for i, tt := range []struct { + name string + gates []string + optIn bool + wantCode codes.Code + }{ + {name: "gate off", optIn: true, wantCode: codes.InvalidArgument}, + {name: "no opt-in", gates: []string{"GoldenEgressPolicy"}, wantCode: codes.InvalidArgument}, + {name: "unrelated gate", gates: []string{"ExternalVolumes"}, optIn: true, wantCode: codes.InvalidArgument}, + {name: "gate on and opt-in", gates: []string{"GoldenEgressPolicy"}, optIn: true, wantCode: codes.OK}, + {name: "all gates and opt-in", gates: []string{"ALL"}, optIn: true, wantCode: codes.OK}, + } { + t.Run(tt.name, func(t *testing.T) { + preview.InitForTest(t, tt.gates...) + client := tc.noOptInClient + if tt.optIn { + client = tc.client + } + tmpl := proto.Clone(base).(*ateapipb.ActorTemplate) + tmpl.Metadata = &ateapipb.ResourceMetadata{Atespace: testAtespace, Name: fmt.Sprintf("golden-egress-%d", i)} + tmpl.Status = nil + tmpl.GoldenEgressPolicy = &ateapipb.EgressPolicyTemplate{Rules: functionalEgressPolicy().Rules} + ref := resources.ActorTemplateRefFromActorTemplate(tmpl).ToObjectRef() + created, err := client.CreateActorTemplate(t.Context(), &ateapipb.CreateActorTemplateRequest{ActorTemplate: tmpl}) + if tt.wantCode != codes.OK { + assertGrpcErrorRegex(t, err, tt.wantCode, "golden_egress_policy") + _, err = client.GetActorTemplate(t.Context(), &ateapipb.GetActorTemplateRequest{ActorTemplate: ref}) + assertGrpcErrorRegex(t, err, codes.NotFound, "not found") + return + } + if err != nil { + t.Fatalf("CreateActorTemplate: %v", err) + } + wantPolicy := &ateapipb.EgressPolicyTemplate{Rules: []*ateapipb.EgressRule{{ + Http: &ateapipb.HttpRule{Hostnames: []string{"api.example.com"}, Ports: &ateapipb.Ports{Numbers: []int32{80}}}, + }}} + if diff := cmp.Diff(wantPolicy, created.GetGoldenEgressPolicy(), protocmp.Transform()); diff != "" { + t.Fatalf("golden policy (-want +got):\n%s", diff) + } + + // Opting out or disabling the gate must not strand existing templates. + preview.InitForTest(t) + got, err := tc.noOptInClient.GetActorTemplate(t.Context(), &ateapipb.GetActorTemplateRequest{ActorTemplate: ref}) + if err != nil { + t.Fatalf("GetActorTemplate with gate disabled: %v", err) + } + if diff := cmp.Diff(created, got, protocmp.Transform()); diff != "" { + t.Fatalf("template changed with gate disabled (-want +got):\n%s", diff) + } + if _, err := tc.noOptInClient.DeleteActorTemplate(t.Context(), &ateapipb.DeleteActorTemplateRequest{ActorTemplate: ref}); err != nil { + t.Fatalf("DeleteActorTemplate with gate disabled: %v", err) + } + }) + } +} diff --git a/cmd/ateapi/internal/controlapi/functionaltest/actor_test.go b/cmd/ateapi/internal/controlapi/functionaltest/actor_test.go index 02f6acd32d..9dd334389d 100644 --- a/cmd/ateapi/internal/controlapi/functionaltest/actor_test.go +++ b/cmd/ateapi/internal/controlapi/functionaltest/actor_test.go @@ -1387,7 +1387,7 @@ func TestDeleteActor_StateDeleting(t *testing.T) { Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_DELETING}, ActorTemplate: &ateapipb.ObjectRef{Atespace: testAtespace, Name: "tmpl1"}, } - if _, err := tc.persistence.CreateActor(context.Background(), deletingActor); err != nil { + if _, err := tc.persistence.CreateActor(context.Background(), deletingActor, nil); err != nil { t.Fatalf("CreateActor: %v", err) } @@ -1466,7 +1466,7 @@ func TestDeleteActor_WrongState(t *testing.T) { Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_RUNNING}, ActorTemplate: &ateapipb.ObjectRef{Atespace: testAtespace, Name: "tmpl1"}, } - if _, err := tc.persistence.CreateActor(context.Background(), runningActor); err != nil { + if _, err := tc.persistence.CreateActor(context.Background(), runningActor, nil); err != nil { t.Fatalf("CreateActor: %v", err) } @@ -1513,7 +1513,7 @@ func TestDeleteActor_MultipleVolumeDeletionFailures(t *testing.T) { }, }, } - if _, err := tc.persistence.CreateActor(context.Background(), actor); err != nil { + if _, err := tc.persistence.CreateActor(context.Background(), actor, nil); err != nil { t.Fatalf("CreateActor: %v", err) } @@ -1590,7 +1590,7 @@ func TestDeleteActor_VolumeDeletionFailure_RetrySuccess(t *testing.T) { }, }, } - if _, err := tc.persistence.CreateActor(context.Background(), actor); err != nil { + if _, err := tc.persistence.CreateActor(context.Background(), actor, nil); err != nil { t.Fatalf("CreateActor: %v", err) } diff --git a/cmd/ateapi/internal/controlapi/functionaltest/egress_policy_test.go b/cmd/ateapi/internal/controlapi/functionaltest/egress_policy_test.go index 65c5693b9f..ae4d424e48 100644 --- a/cmd/ateapi/internal/controlapi/functionaltest/egress_policy_test.go +++ b/cmd/ateapi/internal/controlapi/functionaltest/egress_policy_test.go @@ -19,6 +19,7 @@ import ( "testing" "time" + "github.com/agent-substrate/substrate/internal/preview" "github.com/agent-substrate/substrate/internal/resources" "github.com/agent-substrate/substrate/pkg/proto/ateapipb" "github.com/google/go-cmp/cmp" @@ -66,6 +67,111 @@ func createEgressPolicy(t *testing.T, tc *testContext, actor *ateapipb.ObjectRef return created } +func TestCreateActor_InitialEgressPolicy(t *testing.T) { + // Explicit initial policies do not require the golden policy preview gate + // or a client that opts in to preview features. + preview.InitForTest(t) + ns := namespaceForTest("ns-initial-egress-policy") + tc := setupTest(t, ns) + t.Cleanup(tc.cleanup) + createTemplate(t, tc, ns) + ctx := t.Context() + newPolicy := func(mods ...func(*ateapipb.EgressPolicy)) *ateapipb.EgressPolicy { + policy := &ateapipb.EgressPolicy{ + Metadata: &ateapipb.ResourceMetadata{Atespace: testAtespace, Name: resources.SingletonName}, + Rules: []*ateapipb.EgressRule{ + {Http: &ateapipb.HttpRule{Hostnames: []string{"api.example.com"}}}, + {Https: &ateapipb.HttpsRule{Hostnames: []string{"api.example.com"}}}, + }, + } + for _, mod := range mods { + mod(policy) + } + return policy + } + + for _, tt := range []struct { + name string + policy *ateapipb.EgressPolicy + valid bool + }{ + {name: "omitted", valid: true}, + {name: "configured", valid: true, policy: newPolicy(func(p *ateapipb.EgressPolicy) { + p.Metadata.Uid = "caller-supplied-uid" + p.Metadata.Version = 999 + p.Metadata.CreateTime = timestamppb.New(time.Unix(1, 0)) + p.Metadata.UpdateTime = timestamppb.New(time.Unix(1, 0)) + })}, + {name: "empty", policy: newPolicy(func(p *ateapipb.EgressPolicy) { p.Rules = nil })}, + {name: "missing-metadata", policy: newPolicy(func(p *ateapipb.EgressPolicy) { p.Metadata = nil })}, + {name: "missing-name", policy: newPolicy(func(p *ateapipb.EgressPolicy) { p.Metadata.Name = "" })}, + {name: "wrong-name", policy: newPolicy(func(p *ateapipb.EgressPolicy) { p.Metadata.Name = "custom" })}, + {name: "missing-atespace", policy: newPolicy(func(p *ateapipb.EgressPolicy) { p.Metadata.Atespace = "" })}, + {name: "wrong-atespace", policy: newPolicy(func(p *ateapipb.EgressPolicy) { p.Metadata.Atespace = "other" })}, + {name: "invalid", policy: newPolicy(func(p *ateapipb.EgressPolicy) { p.Rules[0].Http.Hostnames = []string{"bad/host"} })}, + {name: "conflicting", policy: newPolicy(func(p *ateapipb.EgressPolicy) { + p.Rules = append(p.Rules, &ateapipb.EgressRule{TlsPassthrough: &ateapipb.TlsPassthroughRule{Hostnames: []string{"api.example.com"}, Ports: &ateapipb.Ports{Numbers: []int32{443}}}}) + })}, + } { + t.Run(tt.name, func(t *testing.T) { + ref := &ateapipb.ObjectRef{Atespace: testAtespace, Name: tt.name} + req := &ateapipb.CreateActorRequest{ + Actor: &ateapipb.Actor{ + Metadata: &ateapipb.ResourceMetadata{Atespace: ref.Atespace, Name: ref.Name}, + ActorTemplate: &ateapipb.ObjectRef{Atespace: testAtespace, Name: "tmpl1"}, + }, + InitialEgressPolicy: tt.policy, + } + actor, err := tc.client.CreateActor(ctx, req) + if !tt.valid { + assertGrpcErrorRegex(t, err, codes.InvalidArgument, "initial_egress_policy") + _, err = tc.client.GetActor(ctx, &ateapipb.GetActorRequest{Actor: ref}) + assertGrpcErrorRegex(t, err, codes.NotFound, "not found") + _, err = tc.client.GetActorEgressPolicy(ctx, &ateapipb.GetActorEgressPolicyRequest{Actor: ref, Name: resources.SingletonName}) + assertGrpcErrorRegex(t, err, codes.NotFound, "not found") + return + } + if err != nil { + t.Fatalf("CreateActor: %v", err) + } + policy, err := tc.client.GetActorEgressPolicy(ctx, &ateapipb.GetActorEgressPolicyRequest{Actor: ref, Name: resources.SingletonName}) + if tt.policy == nil { + assertGrpcErrorRegex(t, err, codes.NotFound, "not found") + return + } + if err != nil { + t.Fatalf("GetActorEgressPolicy: %v", err) + } + want := &ateapipb.EgressPolicy{Metadata: policy.Metadata, Rules: []*ateapipb.EgressRule{ + {Http: &ateapipb.HttpRule{Hostnames: []string{"api.example.com"}, Ports: &ateapipb.Ports{Numbers: []int32{80}}}}, + {Https: &ateapipb.HttpsRule{Hostnames: []string{"api.example.com"}, Ports: &ateapipb.Ports{Numbers: []int32{443}}}}, + }} + if diff := cmp.Diff(want, policy, protocmp.Transform()); diff != "" { + t.Fatalf("initial policy (-want +got):\n%s", diff) + } + md := policy.GetMetadata() + if md.GetAtespace() != ref.Atespace || md.GetName() != resources.SingletonName || md.GetUid() == "" || md.GetUid() == actor.GetMetadata().GetUid() || md.GetVersion() != 1 || md.GetCreateTime() == nil || md.GetUpdateTime() == nil { + t.Fatalf("unexpected policy metadata: %v", md) + } + if md.GetUid() == "caller-supplied-uid" || md.GetCreateTime().AsTime().Equal(time.Unix(1, 0)) || md.GetUpdateTime().AsTime().Equal(time.Unix(1, 0)) { + t.Fatalf("caller-supplied server metadata was retained: %v", md) + } + + // Repeating CreateActor must not replace the policy on the existing actor. + req.InitialEgressPolicy.Rules = []*ateapipb.EgressRule{{Http: &ateapipb.HttpRule{Hostnames: []string{"other.example.com"}}}} + _, err = tc.client.CreateActor(ctx, req) + assertGrpcErrorRegex(t, err, codes.AlreadyExists, "already exists") + got, err := tc.client.GetActorEgressPolicy(ctx, &ateapipb.GetActorEgressPolicyRequest{Actor: ref, Name: resources.SingletonName}) + if err != nil { + t.Fatal(err) + } + if diff := cmp.Diff(policy, got, protocmp.Transform()); diff != "" { + t.Fatalf("duplicate CreateActor changed policy (-want +got):\n%s", diff) + } + }) + } +} + func TestCreateActorEgressPolicy_Success(t *testing.T) { tc, actor := setupEgressPolicyActor(t, "ns-create-egress-policy") policy := functionalEgressPolicy() diff --git a/cmd/ateapi/internal/controlapi/service.go b/cmd/ateapi/internal/controlapi/service.go index 0c3ae2fc85..c52fdb6a5e 100644 --- a/cmd/ateapi/internal/controlapi/service.go +++ b/cmd/ateapi/internal/controlapi/service.go @@ -39,7 +39,6 @@ import ( type RPCService struct { ateapipb.UnimplementedControlServer impl serviceStore - persistence serviceStore workerCache *workercache.Cache dialer *AteletDialer sandboxConfigLister listersv1alpha1.SandboxConfigLister @@ -91,7 +90,6 @@ func NewRPCService( impl := newServiceImpl(persistence, storageClassLister) s := &RPCService{ impl: impl, - persistence: persistence, workerCache: workerCache, sandboxConfigLister: sandboxConfigLister, csiDriverConfigLister: csiDriverConfigLister, @@ -108,10 +106,9 @@ func NewRPCService( return s } -// serviceStore enumerates the exact storage methods needed by -// the control API and nothing more. +// serviceStore enumerates the service methods consumed by the RPC layer. type serviceStore interface { - CreateActor(ctx context.Context, actor *ateapipb.Actor) (*ateapipb.Actor, error) + CreateActor(ctx context.Context, actor *ateapipb.Actor, policy *ateapipb.EgressPolicy) (*ateapipb.Actor, error) GetActor(ctx context.Context, actorRef resources.ActorRef) (*ateapipb.Actor, error) UpdateActor(ctx context.Context, actorRef resources.ActorRef, precondition store.Precondition, mutate func(toUpdate *ateapipb.Actor) error) (*ateapipb.Actor, error) ListActors(ctx context.Context, atespace string, opts store.ListOptions) (store.ListResponse[*ateapipb.Actor], error) diff --git a/cmd/ateapi/internal/controlapi/template_egress_test.go b/cmd/ateapi/internal/controlapi/template_egress_test.go new file mode 100644 index 0000000000..7903b17dc6 --- /dev/null +++ b/cmd/ateapi/internal/controlapi/template_egress_test.go @@ -0,0 +1,159 @@ +// Copyright 2026 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package controlapi + +import ( + "context" + "errors" + "testing" + + "github.com/agent-substrate/substrate/cmd/ateapi/internal/store/storetest" + "github.com/agent-substrate/substrate/internal/apierror" + "github.com/agent-substrate/substrate/internal/preview" + "github.com/agent-substrate/substrate/internal/resources" + "github.com/agent-substrate/substrate/pkg/proto/ateapipb" + "google.golang.org/grpc/codes" + "google.golang.org/protobuf/proto" +) + +func TestCreateActor_DoesNotInheritGoldenEgressPolicy(t *testing.T) { + preview.InitForTest(t, "GoldenEgressPolicy") + for _, tt := range []struct { + name string + policy *ateapipb.EgressPolicyTemplate + }{ + {name: "absent"}, + {name: "configured", policy: &ateapipb.EgressPolicyTemplate{Rules: []*ateapipb.EgressRule{ + {Http: &ateapipb.HttpRule{Hostnames: []string{"api.example.com"}}}, + {Https: &ateapipb.HttpsRule{Hostnames: []string{"api.example.com"}}}, + }}}, + } { + t.Run(tt.name, func(t *testing.T) { + ctx := t.Context() + persistence := newTestPersistence(t) + svc := &RPCService{impl: newServiceImpl(persistence, nil), sandboxConfigLister: gvisorDefaultLister(t)} + storetest.MustCreateAtespace(t, ctx, persistence, "templates") + storetest.MustCreateAtespace(t, ctx, persistence, "actors") + storetest.MustCreateAtespace(t, ctx, persistence, resources.GoldenActorAtespace) + tmpl, err := svc.CreateActorTemplate(ctx, &ateapipb.CreateActorTemplateRequest{ActorTemplate: validActorTemplate(func(tmpl *ateapipb.ActorTemplate) { + tmpl.Metadata = &ateapipb.ResourceMetadata{Atespace: "templates", Name: "tmpl"} + tmpl.GoldenEgressPolicy = tt.policy + })}) + if err != nil { + t.Fatal(err) + } + tmplRef := resources.ActorTemplateRefFromActorTemplate(tmpl).ToObjectRef() + // Existing templates remain usable without the preview gate. + preview.InitForTest(t) + for _, target := range []resources.ActorRef{ + {Atespace: "actors", Name: "alpha"}, + {Atespace: "actors", Name: tmpl.GetMetadata().GetUid()}, + {Atespace: resources.GoldenActorAtespace, Name: tmpl.GetMetadata().GetUid()}, + } { + actor, err := svc.CreateActor(ctx, &ateapipb.CreateActorRequest{Actor: &ateapipb.Actor{ + Metadata: &ateapipb.ResourceMetadata{Atespace: target.Atespace, Name: target.Name}, ActorTemplate: tmplRef, + }}) + if err != nil { + t.Fatal(err) + } + ref := resources.ActorRefFromActor(actor).ToObjectRef() + if _, err := svc.GetActorEgressPolicy(ctx, &ateapipb.GetActorEgressPolicyRequest{Actor: ref, Name: resources.SingletonName}); apierror.Code(err) != codes.NotFound { + t.Fatalf("actor %v inherited golden policy: %v, want NotFound", target, err) + } + if _, err := svc.CreateActorEgressPolicy(ctx, &ateapipb.CreateActorEgressPolicyRequest{ + Actor: ref, + EgressPolicy: &ateapipb.EgressPolicy{ + Metadata: &ateapipb.ResourceMetadata{Atespace: target.Atespace, Name: resources.SingletonName}, + Rules: []*ateapipb.EgressRule{{Https: &ateapipb.HttpsRule{Hostnames: []string{"runtime.example.com"}}}}, + }, + }); err != nil { + t.Fatalf("creating the actor's runtime policy: %v", err) + } + } + gotTemplate, err := svc.GetActorTemplate(ctx, &ateapipb.GetActorTemplateRequest{ActorTemplate: tmplRef}) + if err != nil || !proto.Equal(gotTemplate, tmpl) { + t.Fatalf("creating runtime policies changed the template: %v, %v", gotTemplate, err) + } + }) + } +} + +type goldenEgressControl struct { + *RPCService + resume func(context.Context, *ateapipb.ResumeActorRequest) (*ateapipb.ResumeActorResponse, error) +} + +func (c *goldenEgressControl) ResumeActor(ctx context.Context, req *ateapipb.ResumeActorRequest) (*ateapipb.ResumeActorResponse, error) { + return c.resume(ctx, req) +} + +func TestReconcileOne_GoldenEgressPolicyBeforeResume(t *testing.T) { + preview.InitForTest(t, "GoldenEgressPolicy") + for _, tt := range []struct { + name string + policy *ateapipb.EgressPolicyTemplate + }{ + {name: "absent"}, + {name: "configured", policy: &ateapipb.EgressPolicyTemplate{Rules: []*ateapipb.EgressRule{{Https: &ateapipb.HttpsRule{Hostnames: []string{"api.example.com"}}}}}}, + } { + t.Run(tt.name, func(t *testing.T) { + ctx := t.Context() + persistence := newTestPersistence(t) + svc := &RPCService{impl: newServiceImpl(persistence, nil), sandboxConfigLister: gvisorDefaultLister(t)} + storetest.MustCreateAtespace(t, ctx, persistence, "templates") + tmpl, err := svc.CreateActorTemplate(ctx, &ateapipb.CreateActorTemplateRequest{ActorTemplate: validActorTemplate(func(tmpl *ateapipb.ActorTemplate) { + tmpl.Metadata = &ateapipb.ResourceMetadata{Atespace: "templates", Name: "tmpl"} + tmpl.GoldenEgressPolicy = tt.policy + })}) + if err != nil { + t.Fatal(err) + } + stop := errors.New("stop before running workload") + control := &goldenEgressControl{RPCService: svc, resume: func(ctx context.Context, req *ateapipb.ResumeActorRequest) (*ateapipb.ResumeActorResponse, error) { + ref := req.GetActor() + if ref.GetAtespace() != resources.GoldenActorAtespace || ref.GetName() != tmpl.GetMetadata().GetUid() { + t.Fatalf("unexpected golden actor: %v", ref) + } + policy, err := svc.GetActorEgressPolicy(ctx, &ateapipb.GetActorEgressPolicyRequest{Actor: ref, Name: resources.SingletonName}) + if tt.policy == nil { + if apierror.Code(err) != codes.NotFound { + t.Fatalf("golden without configured policy: %v, want NotFound", err) + } + return nil, stop + } + if err != nil { + t.Fatalf("golden policy must exist before resume: %v", err) + } + want := &ateapipb.EgressPolicy{Metadata: policy.Metadata, Rules: tmpl.GetGoldenEgressPolicy().GetRules()} + if policy.GetMetadata().GetAtespace() != resources.GoldenActorAtespace || policy.GetMetadata().GetName() != "default" || !proto.Equal(policy, want) { + t.Fatalf("golden policy = %v, want rules %v in ate-golden", policy, want.Rules) + } + if md := policy.GetMetadata(); md.GetUid() == "" || md.GetVersion() != 1 || md.GetCreateTime() == nil || md.GetUpdateTime() == nil { + t.Errorf("unexpected policy metadata: %v", md) + } + return nil, stop + }} + r := newTestTemplateReconciler(persistence, control) + defer r.queue.ShutDown() + // Turning the gate off must not drop an existing template's policy. + preview.InitForTest(t) + for range 2 { + if _, err := r.reconcileOne(ctx, resources.ActorTemplateRefFromActorTemplate(tmpl)); !errors.Is(err, stop) { + t.Fatalf("reconcile = %v, want to reach resume with the policy present", err) + } + } + }) + } +} diff --git a/cmd/ateapi/internal/controlapi/template_reconciler.go b/cmd/ateapi/internal/controlapi/template_reconciler.go index 2a00e3439b..05036d957d 100644 --- a/cmd/ateapi/internal/controlapi/template_reconciler.go +++ b/cmd/ateapi/internal/controlapi/template_reconciler.go @@ -439,6 +439,13 @@ func (r *ActorTemplateReconciler) ensureActorExists(ctx context.Context, tmpl *a }); err != nil && apierror.Code(err) != codes.AlreadyExists { return nil, fmt.Errorf("while ensuring atespace %q: %w", goldenActorRef.GetAtespace(), err) } + var policy *ateapipb.EgressPolicy + if initial := tmpl.GetGoldenEgressPolicy(); initial != nil { + policy = &ateapipb.EgressPolicy{ + Metadata: &ateapipb.ResourceMetadata{Atespace: goldenActorRef.GetAtespace(), Name: resources.SingletonName}, + Rules: initial.GetRules(), + } + } actor, err = r.control.CreateActor(ctx, &ateapipb.CreateActorRequest{ Actor: &ateapipb.Actor{ Metadata: &ateapipb.ResourceMetadata{ @@ -447,6 +454,7 @@ func (r *ActorTemplateReconciler) ensureActorExists(ctx context.Context, tmpl *a }, ActorTemplate: resources.ActorTemplateRefFromActorTemplate(tmpl).ToObjectRef(), }, + InitialEgressPolicy: policy, }) if err != nil { return nil, fmt.Errorf("while creating golden actor: %w", err) diff --git a/cmd/ateapi/internal/defaults/defaults.go b/cmd/ateapi/internal/defaults/defaults.go index ff31f792d4..66e97c18d1 100644 --- a/cmd/ateapi/internal/defaults/defaults.go +++ b/cmd/ateapi/internal/defaults/defaults.go @@ -52,6 +52,7 @@ func applyActorTemplateDefaults(t *ateapipb.ActorTemplate) { return } applySnapshotConfigDefaults(t.SnapshotConfig) + applyEgressRuleDefaults(t.GetGoldenEgressPolicy().GetRules()) for _, c := range t.Containers { applyContainerDefaults(c) } @@ -94,14 +95,15 @@ func applyActorDefaults(*ateapipb.Actor) {} func applyAtespaceDefaults(*ateapipb.Atespace) {} -// applyEgressPolicyDefaults fills the port of an http or https rule that +func applyEgressPolicyDefaults(p *ateapipb.EgressPolicy) { + applyEgressRuleDefaults(p.GetRules()) +} + +// applyEgressRuleDefaults fills the port of an http or https rule that // names none: the protocol's well-known port. A tls_passthrough rule has no // default; validation requires its ports. -func applyEgressPolicyDefaults(p *ateapipb.EgressPolicy) { - if p == nil { - return - } - for _, r := range p.Rules { +func applyEgressRuleDefaults(rules []*ateapipb.EgressRule) { + for _, r := range rules { switch { case r.GetHttp() != nil && r.Http.Ports == nil: r.Http.Ports = &ateapipb.Ports{Numbers: []int32{80}} diff --git a/cmd/ateapi/internal/defaults/defaults_test.go b/cmd/ateapi/internal/defaults/defaults_test.go index 5ccb5ba159..44afc61ec8 100644 --- a/cmd/ateapi/internal/defaults/defaults_test.go +++ b/cmd/ateapi/internal/defaults/defaults_test.go @@ -130,6 +130,20 @@ func TestApply(t *testing.T) { {TlsPassthrough: &ateapipb.TlsPassthroughRule{Hostnames: []string{"d.example.com"}}}, {}, }}, + }, { + name: "template defaults egress ports", + in: &ateapipb.ActorTemplate{GoldenEgressPolicy: &ateapipb.EgressPolicyTemplate{Rules: []*ateapipb.EgressRule{ + {Http: &ateapipb.HttpRule{Hostnames: []string{"api.example.com"}}}, + {Https: &ateapipb.HttpsRule{Hostnames: []string{"api.example.com"}}}, + {Https: &ateapipb.HttpsRule{Hostnames: []string{"custom.example.com"}, Ports: &ateapipb.Ports{Numbers: []int32{8443}}}}, + {TlsPassthrough: &ateapipb.TlsPassthroughRule{Hostnames: []string{"tcp.example.com"}}}, + }}}, + want: &ateapipb.ActorTemplate{GoldenEgressPolicy: &ateapipb.EgressPolicyTemplate{Rules: []*ateapipb.EgressRule{ + {Http: &ateapipb.HttpRule{Hostnames: []string{"api.example.com"}, Ports: &ateapipb.Ports{Numbers: []int32{80}}}}, + {Https: &ateapipb.HttpsRule{Hostnames: []string{"api.example.com"}, Ports: &ateapipb.Ports{Numbers: []int32{443}}}}, + {Https: &ateapipb.HttpsRule{Hostnames: []string{"custom.example.com"}, Ports: &ateapipb.Ports{Numbers: []int32{8443}}}}, + {TlsPassthrough: &ateapipb.TlsPassthroughRule{Hostnames: []string{"tcp.example.com"}}}, + }}}, }, { name: "tag has no defaults", in: &ateapipb.Tag{Scope: ateapipb.TagScope_TAG_SCOPE_PUBLISHED}, diff --git a/cmd/ateapi/internal/store/atepg/actor.go b/cmd/ateapi/internal/store/atepg/actor.go index 538d263511..c1b27ceb31 100644 --- a/cmd/ateapi/internal/store/atepg/actor.go +++ b/cmd/ateapi/internal/store/atepg/actor.go @@ -26,7 +26,30 @@ import ( "google.golang.org/protobuf/proto" ) -func (p *Persistence) CreateActor(ctx context.Context, actor *ateapipb.Actor) (*ateapipb.Actor, error) { +func (p *Persistence) CreateActor(ctx context.Context, actor *ateapipb.Actor, policy *ateapipb.EgressPolicy) (*ateapipb.Actor, error) { + if policy == nil { + return createActor(ctx, p.pool, actor) + } + tx, err := p.pool.Begin(ctx) + if err != nil { + return nil, err + } + defer func() { _ = tx.Rollback(ctx) }() + + dbActor, err := createActor(ctx, tx, actor) + if err != nil { + return nil, err + } + if _, err := createEgressPolicy(ctx, tx, resources.ActorRefFromActor(dbActor), policy); err != nil { + return nil, err + } + if err := tx.Commit(ctx); err != nil { + return nil, err + } + return dbActor, nil +} + +func createActor(ctx context.Context, q querier, actor *ateapipb.Actor) (*ateapipb.Actor, error) { atespace := actor.GetMetadata().GetAtespace() name := actor.GetMetadata().GetName() @@ -42,7 +65,7 @@ func (p *Persistence) CreateActor(ctx context.Context, actor *ateapipb.Actor) (* return nil, fmt.Errorf("marshaling actor: %w", err) } - _, err = p.pool.Exec(ctx, ` + _, err = q.Exec(ctx, ` INSERT INTO actors (atespace, name, uid, version, proto) VALUES ($1, $2, $3, $4, $5)`, atespace, name, dbActor.GetMetadata().GetUid(), dbActor.GetMetadata().GetVersion(), protoBytes) diff --git a/cmd/ateapi/internal/store/atepg/actor_test.go b/cmd/ateapi/internal/store/atepg/actor_test.go index 337a758663..e8d4cf5f8e 100644 --- a/cmd/ateapi/internal/store/atepg/actor_test.go +++ b/cmd/ateapi/internal/store/atepg/actor_test.go @@ -23,6 +23,7 @@ import ( "github.com/agent-substrate/substrate/cmd/ateapi/internal/store" "github.com/agent-substrate/substrate/internal/resources" "github.com/agent-substrate/substrate/pkg/proto/ateapipb" + "google.golang.org/protobuf/proto" ) func TestUpdateActor_ConcurrentWriteReturnsConflict(t *testing.T) { @@ -33,7 +34,7 @@ func TestUpdateActor_ConcurrentWriteReturnsConflict(t *testing.T) { Metadata: &ateapipb.ResourceMetadata{Atespace: "team-a", Name: "actor-a"}, ActorTemplate: &ateapipb.ObjectRef{Atespace: "default", Name: "template-a"}, Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_SUSPENDED}, - }) + }, nil) if err != nil { t.Fatalf("CreateActor failed: %v", err) } @@ -85,11 +86,80 @@ func TestCreateActor_MissingAtespace_FailedPrecondition(t *testing.T) { ActorTemplate: &ateapipb.ObjectRef{Atespace: "ns1", Name: "tmpl1"}, Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_SUSPENDED}, } - if _, err := s.CreateActor(ctx, actor); !errors.Is(err, store.ErrFailedPrecondition) { + if _, err := s.CreateActor(ctx, actor, nil); !errors.Is(err, store.ErrFailedPrecondition) { t.Errorf("CreateActor with missing atespace = %v, want ErrFailedPrecondition", err) } } +func TestCreateActor_EgressPolicyRollback(t *testing.T) { + p := setupPostgresPersistence(t) + ctx := t.Context() + createTestAtespace(t, p, "team-a") + actor := &ateapipb.Actor{ + Metadata: &ateapipb.ResourceMetadata{Atespace: "team-a", Name: "fail-policy"}, + Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_SUSPENDED}, + } + policy := &ateapipb.EgressPolicy{ + Metadata: &ateapipb.ResourceMetadata{Atespace: "team-a", Name: "default"}, + Rules: []*ateapipb.EgressRule{{ + Http: &ateapipb.HttpRule{Hostnames: []string{"api.example.com"}, Ports: &ateapipb.Ports{Numbers: []int32{80}}}, + }}, + } + wantActor, wantPolicy := proto.CloneOf(actor), proto.CloneOf(policy) + ref := resources.ActorRefFromActor(actor) + + // Fail the policy INSERT after the actor INSERT has succeeded. + if _, err := p.pool.Exec(ctx, `ALTER TABLE actor_egress_policies ADD CONSTRAINT fail_policy CHECK (actor_name <> 'fail-policy')`); err != nil { + t.Fatal(err) + } + t.Cleanup(func() { + if _, err := p.pool.Exec(context.Background(), `ALTER TABLE actor_egress_policies DROP CONSTRAINT IF EXISTS fail_policy`); err != nil { + t.Error(err) + } + }) + if _, err := p.CreateActor(ctx, actor, policy); err == nil { + t.Fatal("expected policy insert failure") + } + if _, err := p.GetActor(ctx, ref); !errors.Is(err, store.ErrNotFound) { + t.Fatalf("actor after rollback: %v, want ErrNotFound", err) + } + if _, err := p.GetEgressPolicy(ctx, ref); !errors.Is(err, store.ErrNotFound) { + t.Fatalf("policy after rollback: %v, want ErrNotFound", err) + } + if _, err := p.pool.Exec(ctx, `ALTER TABLE actor_egress_policies DROP CONSTRAINT fail_policy`); err != nil { + t.Fatal(err) + } + created, err := p.CreateActor(ctx, actor, policy) + if err != nil { + t.Fatalf("retry: %v", err) + } + got, err := p.GetActor(ctx, ref) + if err != nil { + t.Fatal(err) + } + if !proto.Equal(created, got) { + t.Errorf("stored actor = %v, want %v", got, created) + } + if !proto.Equal(wantActor, actor) || !proto.Equal(wantPolicy, policy) { + t.Error("CreateActor mutated its inputs") + } + if _, err := p.CreateActor(ctx, actor, &ateapipb.EgressPolicy{}); !errors.Is(err, store.ErrAlreadyExists) { + t.Fatalf("duplicate create: %v, want ErrAlreadyExists", err) + } + storedPolicy, err := p.GetEgressPolicy(ctx, ref) + if err != nil { + t.Fatal(err) + } + wantPolicy.Metadata = storedPolicy.Metadata + if !proto.Equal(wantPolicy, storedPolicy) { + t.Errorf("stored policy = %v, want %v", storedPolicy, wantPolicy) + } + md := storedPolicy.GetMetadata() + if md.GetAtespace() != ref.Atespace || md.GetName() != "default" || md.GetUid() == "" || md.GetUid() == created.GetMetadata().GetUid() || md.GetVersion() != 1 || md.GetCreateTime() == nil || md.GetUpdateTime() == nil { + t.Errorf("unexpected policy metadata: %v", md) + } +} + func TestListActors_InvalidPageToken(t *testing.T) { s := setupPostgresPersistence(t) ctx := context.Background() @@ -110,7 +180,7 @@ func TestListActors_CrossScopePageToken(t *testing.T) { t.Fatalf("CreateAtespace(team-b) failed: %v", err) } for _, name := range []string{"a1", "a2"} { - if _, err := s.CreateActor(ctx, &ateapipb.Actor{Metadata: &ateapipb.ResourceMetadata{Name: name, Atespace: "team-a"}, Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_SUSPENDED}}); err != nil { + if _, err := s.CreateActor(ctx, &ateapipb.Actor{Metadata: &ateapipb.ResourceMetadata{Name: name, Atespace: "team-a"}, Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_SUSPENDED}}, nil); err != nil { t.Fatalf("CreateActor failed: %v", err) } } diff --git a/cmd/ateapi/internal/store/atepg/atepg_test.go b/cmd/ateapi/internal/store/atepg/atepg_test.go index 6c0e6c0bb0..a456265b07 100644 --- a/cmd/ateapi/internal/store/atepg/atepg_test.go +++ b/cmd/ateapi/internal/store/atepg/atepg_test.go @@ -34,7 +34,7 @@ func TestList_NamesAnUndecodableRow(t *testing.T) { if _, err := s.CreateActor(ctx, &ateapipb.Actor{ Metadata: &ateapipb.ResourceMetadata{Name: "a1", Atespace: "team-a"}, Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_SUSPENDED}, - }); err != nil { + }, nil); err != nil { t.Fatalf("CreateActor failed: %v", err) } if _, err := s.CreateWorker(ctx, &ateapipb.Worker{ diff --git a/cmd/ateapi/internal/store/atepg/egress_policy.go b/cmd/ateapi/internal/store/atepg/egress_policy.go index 70c679656b..d5ec2e431d 100644 --- a/cmd/ateapi/internal/store/atepg/egress_policy.go +++ b/cmd/ateapi/internal/store/atepg/egress_policy.go @@ -27,13 +27,17 @@ import ( ) func (p *Persistence) CreateEgressPolicy(ctx context.Context, actorRef resources.ActorRef, policy *ateapipb.EgressPolicy) (*ateapipb.EgressPolicy, error) { + return createEgressPolicy(ctx, p.pool, actorRef, policy) +} + +func createEgressPolicy(ctx context.Context, q querier, actorRef resources.ActorRef, policy *ateapipb.EgressPolicy) (*ateapipb.EgressPolicy, error) { dbPolicy := proto.Clone(policy).(*ateapipb.EgressPolicy) setCreateMetadata(dbPolicy.Metadata) protoBytes, err := proto.Marshal(dbPolicy) if err != nil { return nil, fmt.Errorf("marshaling egress policy: %w", err) } - _, err = p.pool.Exec(ctx, ` + _, err = q.Exec(ctx, ` INSERT INTO actor_egress_policies (atespace, actor_name, uid, version, proto) VALUES ($1, $2, $3, $4, $5)`, actorRef.Atespace, actorRef.Name, dbPolicy.GetMetadata().GetUid(), dbPolicy.GetMetadata().GetVersion(), protoBytes) if err != nil { diff --git a/cmd/ateapi/internal/store/store.go b/cmd/ateapi/internal/store/store.go index cc494082c1..52c956cc23 100644 --- a/cmd/ateapi/internal/store/store.go +++ b/cmd/ateapi/internal/store/store.go @@ -70,7 +70,10 @@ type Interface interface { // server-assigned metadata (uid, version, timestamps). The input is not // mutated. Returns ErrAlreadyExists if key is taken, or // ErrFailedPrecondition if the actor's atespace does not exist. - CreateActor(ctx context.Context, actor *ateapipb.Actor) (*ateapipb.Actor, error) + // If policy is non-nil, atomically creates it with the actor, assigning fresh + // server metadata without mutating either input. Its metadata must specify + // the actor's atespace and the name "default". A nil policy creates no policy. + CreateActor(ctx context.Context, actor *ateapipb.Actor, policy *ateapipb.EgressPolicy) (*ateapipb.Actor, error) // Fetches an actor by reference. Returns ErrNotFound if missing. GetActor(ctx context.Context, actorRef resources.ActorRef) (*ateapipb.Actor, error) diff --git a/cmd/ateapi/internal/store/storecontract/contract.go b/cmd/ateapi/internal/store/storecontract/contract.go index 2093146326..218d5c4b69 100644 --- a/cmd/ateapi/internal/store/storecontract/contract.go +++ b/cmd/ateapi/internal/store/storecontract/contract.go @@ -224,7 +224,7 @@ func runEgressPolicyContractTests(t *testing.T, setup func(t *testing.T) store.I actor, err := s.CreateActor(ctx, &ateapipb.Actor{ Metadata: &ateapipb.ResourceMetadata{Atespace: testAtespace, Name: "session-1"}, Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_RUNNING}, - }) + }, nil) if err != nil { t.Fatal(err) } @@ -282,7 +282,7 @@ func runEgressPolicyContractTests(t *testing.T, setup func(t *testing.T) store.I ctx := context.Background() mustCreateAtespace(t, s, testAtespace) actorRef := resources.ActorRef{Atespace: testAtespace, Name: "session-1"} - if _, err := s.CreateActor(ctx, newTestSuspendedActor(testAtespace, actorRef.Name)); err != nil { + if _, err := s.CreateActor(ctx, newTestSuspendedActor(testAtespace, actorRef.Name), nil); err != nil { t.Fatalf("CreateActor failed: %v", err) } create := func() *ateapipb.EgressPolicy { @@ -351,7 +351,7 @@ func runEgressPolicyContractTests(t *testing.T, setup func(t *testing.T) store.I actor, err := s.CreateActor(ctx, &ateapipb.Actor{ Metadata: &ateapipb.ResourceMetadata{Atespace: testAtespace, Name: actorRef.Name}, Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_DELETING}, - }) + }, nil) if err != nil { t.Fatal(err) } @@ -367,7 +367,7 @@ func runEgressPolicyContractTests(t *testing.T, setup func(t *testing.T) store.I replacement, err := s.CreateActor(ctx, &ateapipb.Actor{ Metadata: &ateapipb.ResourceMetadata{Atespace: testAtespace, Name: actorRef.Name}, Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_RUNNING}, - }) + }, nil) if err != nil { t.Fatal(err) } @@ -455,7 +455,7 @@ func runActorContractTests(t *testing.T, setup func(t *testing.T) store.Interfac Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_SUSPENDED}, } - created, err := s.CreateActor(ctx, actor) + created, err := s.CreateActor(ctx, actor, nil) if err != nil { t.Fatalf("CreateActor failed: %v", err) } @@ -500,10 +500,10 @@ func runActorContractTests(t *testing.T, setup func(t *testing.T) store.Interfac Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_SUSPENDED}, } - if _, err := s.CreateActor(ctx, actor); err != nil { + if _, err := s.CreateActor(ctx, actor, nil); err != nil { t.Fatalf("CreateActor failed: %v", err) } - if _, err := s.CreateActor(ctx, actor); !errors.Is(err, store.ErrAlreadyExists) { + if _, err := s.CreateActor(ctx, actor, nil); !errors.Is(err, store.ErrAlreadyExists) { t.Errorf("expected ErrAlreadyExists, got %v", err) } }) @@ -519,7 +519,7 @@ func runActorContractTests(t *testing.T, setup func(t *testing.T) store.Interfac Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_SUSPENDED}, } - created, err := s.CreateActor(ctx, actor) + created, err := s.CreateActor(ctx, actor, nil) if err != nil { t.Fatalf("CreateActor failed: %v", err) } @@ -575,7 +575,7 @@ func runActorContractTests(t *testing.T, setup func(t *testing.T) store.Interfac Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_SUSPENDED}, } - if _, err := s.CreateActor(ctx, actor); err != nil { + if _, err := s.CreateActor(ctx, actor, nil); err != nil { t.Fatalf("CreateActor failed: %v", err) } @@ -618,7 +618,7 @@ func runActorContractTests(t *testing.T, setup func(t *testing.T) store.Interfac } } - original, err := s.CreateActor(ctx, newActor()) + original, err := s.CreateActor(ctx, newActor(), nil) if err != nil { t.Fatalf("CreateActor failed: %v", err) } @@ -633,7 +633,7 @@ func runActorContractTests(t *testing.T, setup func(t *testing.T) store.Interfac if _, err := s.DeleteActor(ctx, actorRef, store.DeletePreconditions{}); err != nil { t.Fatalf("DeleteActor failed: %v", err) } - recreated, err := s.CreateActor(ctx, newActor()) + recreated, err := s.CreateActor(ctx, newActor(), nil) if err != nil { t.Fatalf("recreate CreateActor failed: %v", err) } @@ -669,7 +669,7 @@ func runActorContractTests(t *testing.T, setup func(t *testing.T) store.Interfac Metadata: &ateapipb.ResourceMetadata{Name: "session-1", Atespace: testAtespace}, ActorTemplate: &ateapipb.ObjectRef{Atespace: "default", Name: "test-template"}, Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_SUSPENDED}, - }) + }, nil) if err != nil { t.Fatalf("CreateActor failed: %v", err) } @@ -700,7 +700,7 @@ func runActorContractTests(t *testing.T, setup func(t *testing.T) store.Interfac Metadata: &ateapipb.ResourceMetadata{Name: "session-1", Atespace: testAtespace}, ActorTemplate: &ateapipb.ObjectRef{Atespace: "default", Name: "test-template"}, Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_SUSPENDED}, - }) + }, nil) if err != nil { t.Fatalf("CreateActor failed: %v", err) } @@ -760,7 +760,7 @@ func runActorContractTests(t *testing.T, setup func(t *testing.T) store.Interfac Metadata: &ateapipb.ResourceMetadata{Name: actorRef.Name, Atespace: testAtespace}, ActorTemplate: &ateapipb.ObjectRef{Atespace: "default", Name: "test-template"}, Status: &ateapipb.ActorStatus{State: state}, - }); err != nil { + }, nil); err != nil { t.Fatalf("CreateActor failed: %v", err) } @@ -793,7 +793,7 @@ func runActorContractTests(t *testing.T, setup func(t *testing.T) store.Interfac mustCreateAtespace(t, s, testAtespace) actorRef := resources.ActorRef{Atespace: testAtespace, Name: "session-1"} create := func() *ateapipb.Actor { - created, err := s.CreateActor(ctx, newTestSuspendedActor(testAtespace, actorRef.Name)) + created, err := s.CreateActor(ctx, newTestSuspendedActor(testAtespace, actorRef.Name), nil) if err != nil { t.Fatalf("CreateActor failed: %v", err) } @@ -894,10 +894,10 @@ func runActorContractTests(t *testing.T, setup func(t *testing.T) store.Interfac }}, }, } - if _, err := s.CreateActor(ctx, actor1); err != nil { + if _, err := s.CreateActor(ctx, actor1, nil); err != nil { t.Fatalf("failed to create actor1: %v", err) } - if _, err := s.CreateActor(ctx, actor2); err != nil { + if _, err := s.CreateActor(ctx, actor2, nil); err != nil { t.Fatalf("failed to create actor2: %v", err) } @@ -925,7 +925,7 @@ func runActorContractTests(t *testing.T, setup func(t *testing.T) store.Interfac ActorTemplate: &ateapipb.ObjectRef{Atespace: "ns1", Name: "tmpl1"}, Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_SUSPENDED}, } - if _, err := s.CreateActor(ctx, actor); err != nil { + if _, err := s.CreateActor(ctx, actor, nil); err != nil { t.Fatalf("failed to create actor %d: %v", i, err) } } @@ -970,7 +970,7 @@ func runActorContractTests(t *testing.T, setup func(t *testing.T) store.Interfac } } for _, a := range []*ateapipb.Actor{mkActor("team-a", "a1"), mkActor("team-a", "a2"), mkActor("team-b", "b1")} { - if _, err := s.CreateActor(ctx, a); err != nil { + if _, err := s.CreateActor(ctx, a, nil); err != nil { t.Fatalf("CreateActor(%s/%s) failed: %v", a.GetMetadata().GetAtespace(), a.GetMetadata().GetName(), err) } } @@ -1209,7 +1209,7 @@ func runTagContractTests(t *testing.T, setup func(t *testing.T) store.Interface) seedSuspendedActor := func(t *testing.T, s store.Interface, atespace, name string) *ateapipb.Actor { t.Helper() mustCreateAtespace(t, s, atespace) - actor, err := s.CreateActor(context.Background(), newTestSuspendedActor(atespace, name)) + actor, err := s.CreateActor(context.Background(), newTestSuspendedActor(atespace, name), nil) if err != nil { t.Fatalf("CreateActor(%s/%s) failed: %v", atespace, name, err) } @@ -1298,7 +1298,7 @@ func runTagContractTests(t *testing.T, setup func(t *testing.T) store.Interface) s := setup(t) ctx := context.Background() mustCreateAtespace(t, s, testAtespace) - actor, err := s.CreateActor(ctx, newTestSuspendedActor(testAtespace, "actor-1")) + actor, err := s.CreateActor(ctx, newTestSuspendedActor(testAtespace, "actor-1"), nil) if err != nil { t.Fatalf("CreateActor failed: %v", err) } @@ -2987,7 +2987,7 @@ func runAtespaceContractTests(t *testing.T, setup func(t *testing.T) store.Inter // Matching guards do not override the emptiness rule. actorRef := resources.ActorRef{Atespace: "team-a", Name: "id1"} - if _, err := s.CreateActor(ctx, newTestSuspendedActor(actorRef.Atespace, actorRef.Name)); err != nil { + if _, err := s.CreateActor(ctx, newTestSuspendedActor(actorRef.Atespace, actorRef.Name), nil); err != nil { t.Fatalf("CreateActor failed: %v", err) } if err := del(store.DeletePreconditions{UID: uid, Version: version}); !errors.Is(err, store.ErrFailedPrecondition) { @@ -3023,7 +3023,7 @@ func runAtespaceContractTests(t *testing.T, setup func(t *testing.T) store.Inter if _, err := s.CreateAtespace(ctx, newTestAtespace("team-a")); err != nil { t.Fatalf("CreateAtespace failed: %v", err) } - if _, err := s.CreateActor(ctx, &ateapipb.Actor{Metadata: &ateapipb.ResourceMetadata{Name: "id1", Atespace: "team-a"}, Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_DELETING}}); err != nil { + if _, err := s.CreateActor(ctx, &ateapipb.Actor{Metadata: &ateapipb.ResourceMetadata{Name: "id1", Atespace: "team-a"}, Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_DELETING}}, nil); err != nil { t.Fatalf("CreateActor failed: %v", err) } if _, err := s.DeleteAtespace(ctx, "team-a", store.DeletePreconditions{}); !errors.Is(err, store.ErrFailedPrecondition) { @@ -3041,7 +3041,7 @@ func runAtespaceContractTests(t *testing.T, setup func(t *testing.T) store.Inter if _, err := s.CreateAtespace(ctx, newTestAtespace("team-a")); err != nil { t.Fatalf("CreateAtespace failed: %v", err) } - if _, err := s.CreateActor(ctx, &ateapipb.Actor{Metadata: &ateapipb.ResourceMetadata{Name: "id1", Atespace: "team-a"}, Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_DELETING}}); err != nil { + if _, err := s.CreateActor(ctx, &ateapipb.Actor{Metadata: &ateapipb.ResourceMetadata{Name: "id1", Atespace: "team-a"}, Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_DELETING}}, nil); err != nil { t.Fatalf("CreateActor failed: %v", err) } if _, err := s.DeleteAtespace(ctx, "team-a", store.DeletePreconditions{}); !errors.Is(err, store.ErrFailedPrecondition) { @@ -3065,7 +3065,7 @@ func runAtespaceContractTests(t *testing.T, setup func(t *testing.T) store.Inter if _, err := s.CreateAtespace(ctx, newTestAtespace("team-b")); err != nil { t.Fatalf("CreateAtespace(team-b) failed: %v", err) } - if _, err := s.CreateActor(ctx, &ateapipb.Actor{Metadata: &ateapipb.ResourceMetadata{Name: "id1", Atespace: "team-b"}, Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_SUSPENDED}}); err != nil { + if _, err := s.CreateActor(ctx, &ateapipb.Actor{Metadata: &ateapipb.ResourceMetadata{Name: "id1", Atespace: "team-b"}, Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_SUSPENDED}}, nil); err != nil { t.Fatalf("CreateActor failed: %v", err) } @@ -3175,7 +3175,7 @@ func runUnknownFieldContractTests(t *testing.T, setup func(t *testing.T) store.I Metadata: withUnknownField(&ateapipb.ResourceMetadata{Atespace: testAtespace, Name: "actor-1"}), ActorTemplate: withUnknownField(&ateapipb.ObjectRef{Atespace: testAtespace, Name: "tmpl-1"}), Status: withUnknownField(&ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_DELETING}), - })) + }), nil) if err != nil { t.Fatalf("CreateActor failed: %v", err) } @@ -3216,7 +3216,7 @@ func runUnknownFieldContractTests(t *testing.T, setup func(t *testing.T) store.I actor, err := s.CreateActor(ctx, &ateapipb.Actor{ Metadata: &ateapipb.ResourceMetadata{Atespace: testAtespace, Name: "actor-1"}, Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_RUNNING}, - }) + }, nil) if err != nil { t.Fatalf("CreateActor failed: %v", err) } @@ -3257,7 +3257,7 @@ func runUnknownFieldContractTests(t *testing.T, setup func(t *testing.T) store.I s := setup(t) ctx := context.Background() mustCreateAtespace(t, s, testAtespace) - actor, err := s.CreateActor(ctx, newTestSuspendedActor(testAtespace, "actor-1")) + actor, err := s.CreateActor(ctx, newTestSuspendedActor(testAtespace, "actor-1"), nil) if err != nil { t.Fatalf("CreateActor failed: %v", err) } diff --git a/cmd/ateapi/internal/store/storetest/storetest.go b/cmd/ateapi/internal/store/storetest/storetest.go index 96d7e17428..4c9cb8058c 100644 --- a/cmd/ateapi/internal/store/storetest/storetest.go +++ b/cmd/ateapi/internal/store/storetest/storetest.go @@ -124,7 +124,7 @@ func MustCreateActor(t *testing.T, ctx context.Context, s store.Interface, actor t.Helper() atespace := actor.GetMetadata().GetAtespace() MustCreateAtespace(t, ctx, s, atespace) - created, err := s.CreateActor(ctx, actor) + created, err := s.CreateActor(ctx, actor, nil) if err != nil { t.Fatalf("creating test actor %q/%q: %v", atespace, actor.GetMetadata().GetName(), err) } diff --git a/docs/api-guide.md b/docs/api-guide.md index 8958b99338..723d21e2b0 100644 --- a/docs/api-guide.md +++ b/docs/api-guide.md @@ -104,11 +104,52 @@ The `ActorTemplate` defines the code, environment, and state-management policies | `snapshotConfig` | `SnapshotConfig` | **Required.** The base object-storage location snapshots are written under, the snapshot fidelity (`preferredFidelity`) every Pause and Suspend captures (`SNAPSHOT_FIDELITY_ROOTFS` requires `sandboxClass: microvm`), and automated golden snapshot creation (`goldenSnapshotConfig.mode`). See [Snapshot Storage Layout](#snapshot-storage-layout). | | `volumes` | `[]Volume` | Optional. Volumes the containers may mount, each a `durableDir`, an `externalVolumeTemplate` (see [CSI Volumes Guide](csi-volumes.md)), or a `systemInfo` volume (see [SystemInfo Volumes](#systeminfo-volumes)). Every declared volume must be mounted by at least one container. A `microvm` template may declare several `durableDir` volumes; a `gvisor` template is limited to one. | | `resources` | `*ResourceRequirements` | Required. Declares each actor's compute size via `limits`, which must set both `cpu` and `memory` — see [Sandbox Right-Sizing](#sandbox-right-sizing-resources). Immutable, like the rest of the template. | +| `goldenEgressPolicy` | `EgressPolicyTemplate` | **Preview.** Optional egress policy for the golden actor during initialization. Requires at least one rule, using the same rule defaults and validation as `EgressPolicy`. See [Golden Egress Policy](#golden-egress-policy-goldenegresspolicy). | The sandbox itself — the binaries (e.g. the gVisor `runsc` binary) and the `pauseImage` holding the sandbox's namespaces — comes from the cluster-scoped [`SandboxConfig`](#3-sandboxconfig-the-sandbox-itself) object the template names via `sandboxConfig.configName`. An actor always resolves the config from its current template — repointing the actor at another template requires the same config. Because a snapshot is not restorable across sandbox runtimes, `sandboxClass` is a **hard scheduling gate**: an actor is only ever placed on a `WorkerPool` whose `sandboxClasses` entry matches. It is AND'd with `workerSelector` (and the actor's `worker_selector`), which can only narrow the eligible pools further. It has no default — `sandboxConfig` is required and its `sandboxClass` must be set — and, like the rest of the template, is immutable, so each template's class is fixed at creation. +### Golden Egress Policy (`goldenEgressPolicy`) + +`goldenEgressPolicy` is a **preview** feature. Enable +`--preview=GoldenEgressPolicy` on the server (or through +ate-setup's `preview` setting), and opt in on the client with `kubectl ate --preview` +or the `Ate-Preview-Allowed: true` gRPC metadata header. See [Preview gates](dev/preview-gates.md). + +Set `goldenEgressPolicy` on an ActorTemplate to give its golden actor network +access during initialization. For example, this template field +allows HTTPS to `api.example.com` on the default port, 443: + +```yaml +goldenEgressPolicy: + rules: + - https: + hostnames: [api.example.com] +``` + +The template controller turns this field into an `EgressPolicy` with the golden +actor's atespace and the name `default`, and passes it as +`CreateActorRequest.initial_egress_policy` when creating the golden actor. +The actor and its `default` egress policy are +created atomically, so the policy exists before golden initialization can start. +The policy receives its own UID, version, and timestamps. The template field +contains only rules. + +Other actors created from the template do not inherit this policy, including +actors restored from its golden snapshot. Configure their network access using +`initial_egress_policy` in `CreateActor`, or subsequently with `CreateActorEgressPolicy`. + +The golden policy's rules are copied once at creation. Updating or deleting +that policy does not change the template. Omitting `goldenEgressPolicy` +creates no golden policy. When set, it must contain at least one rule. + +Turning the gate off prevents creating new templates with `goldenEgressPolicy`. +Existing templates retain their configuration, including when their golden is +created after the gate is turned off. Existing policies and resource cleanup +continue to work. `CreateActorRequest.initial_egress_policy` does not require +this gate or client preview opt-in. + ### Sandbox Right-Sizing (`resources`) Unlike a Pod, an actor is sized by its **`limits`** (CPU and Memory): the size is a property of the template, baked into snapshots, so it lives on the immutable `ActorTemplate`. Both are required. Declared limits do two things: @@ -586,6 +627,7 @@ Registers a new logical actor in the system. * **Request:** `CreateActorRequest` * `actor`: `Actor` — the actor to create. Its `metadata` carries the atespace and name (name must be a DNS-1123 label); the `actor_template` ref (atespace + name) selects the `ActorTemplate`. * `actor.source_tag`: (Optional) `ObjectRef` of a `Tag` to seed the actor from. The tag must be taken under the same `ActorTemplate`, and either in the actor's own atespace or `PUBLISHED`. Nothing is copied: the new actor's `status.snapshots` points at the tag's snapshot, under the tag's prefix, until its own first suspend. + * `initial_egress_policy`: (Optional) `EgressPolicy` containing at least one rule. `metadata.name` must be `default` and `metadata.atespace` must match the actor's atespace, as with `CreateActorEgressPolicy`. Creates the policy atomically with the actor; the server generates the policy's UID, version, and timestamps. Requires permission to create an egress policy on the new actor as well as permission to create the actor and use its template. If omitted, no policy is created or inherited from the template or tag. Manage the resulting policy with the Actor egress policy RPCs. * **Response:** the initialized `Actor`. #### `UpdateActor` diff --git a/internal/preview/preview.go b/internal/preview/preview.go index 968315596c..dd7c4700e4 100644 --- a/internal/preview/preview.go +++ b/internal/preview/preview.go @@ -41,6 +41,9 @@ type Gate string const ( // GateExternalVolumes controls whether external volumes are supported. GateExternalVolumes Gate = "ExternalVolumes" + + // GateGoldenEgressPolicy controls configuring a golden actor's egress policy on its template. + GateGoldenEgressPolicy Gate = "GoldenEgressPolicy" ) // All is the pseudo-gate name that enables every known gate. @@ -50,6 +53,7 @@ const All = "ALL" // default and enabled via the --preview flag. var realKnownGates = []Gate{ GateExternalVolumes, + GateGoldenEgressPolicy, } var globalKnownGates []Gate // all known gates diff --git a/pkg/proto/ateapipb/ateapi.pb.go b/pkg/proto/ateapipb/ateapi.pb.go index ad88e8685f..ae43fac127 100644 --- a/pkg/proto/ateapipb/ateapi.pb.go +++ b/pkg/proto/ateapipb/ateapi.pb.go @@ -1256,6 +1256,61 @@ func (x *EgressPolicy) GetRules() []*EgressRule { return nil } +// EgressPolicyTemplate defines an initial Actor egress policy without resource +// metadata. Each rule has the same defaults, validation, and semantics as +// EgressPolicy.rules. +type EgressPolicyTemplate struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Rules are an unordered set of allows, with the same precedence and effects + // as EgressPolicy.rules. At least one rule is required. Traffic is denied + // when no rule matches. + // + // +k8s:required + // +k8s:maxItems=256 + // +k8s:listType=atomic + // +k8s:customValidation # no two rules tie on a name and port + Rules []*EgressRule `protobuf:"bytes,1,rep,name=rules,proto3" json:"rules,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *EgressPolicyTemplate) Reset() { + *x = EgressPolicyTemplate{} + mi := &file_ateapi_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *EgressPolicyTemplate) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EgressPolicyTemplate) ProtoMessage() {} + +func (x *EgressPolicyTemplate) ProtoReflect() protoreflect.Message { + mi := &file_ateapi_proto_msgTypes[8] + 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 EgressPolicyTemplate.ProtoReflect.Descriptor instead. +func (*EgressPolicyTemplate) Descriptor() ([]byte, []int) { + return file_ateapi_proto_rawDescGZIP(), []int{8} +} + +func (x *EgressPolicyTemplate) GetRules() []*EgressRule { + if x != nil { + return x.Rules + } + return nil +} + // EgressRule allows traffic for a given protocol and destination (host name // or IP, and port). The protocol fixes what the gateway matches on and when: // a request, or a TLS connection at its ClientHello. Traffic that matches no @@ -1289,7 +1344,7 @@ type EgressRule struct { func (x *EgressRule) Reset() { *x = EgressRule{} - mi := &file_ateapi_proto_msgTypes[8] + mi := &file_ateapi_proto_msgTypes[9] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1301,7 +1356,7 @@ func (x *EgressRule) String() string { func (*EgressRule) ProtoMessage() {} func (x *EgressRule) 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 { @@ -1314,7 +1369,7 @@ func (x *EgressRule) ProtoReflect() protoreflect.Message { // Deprecated: Use EgressRule.ProtoReflect.Descriptor instead. func (*EgressRule) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{8} + return file_ateapi_proto_rawDescGZIP(), []int{9} } func (x *EgressRule) GetHttp() *HttpRule { @@ -1382,7 +1437,7 @@ type HttpRule struct { func (x *HttpRule) Reset() { *x = HttpRule{} - mi := &file_ateapi_proto_msgTypes[9] + mi := &file_ateapi_proto_msgTypes[10] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1394,7 +1449,7 @@ func (x *HttpRule) String() string { func (*HttpRule) ProtoMessage() {} func (x *HttpRule) 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 { @@ -1407,7 +1462,7 @@ func (x *HttpRule) ProtoReflect() protoreflect.Message { // Deprecated: Use HttpRule.ProtoReflect.Descriptor instead. func (*HttpRule) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{9} + return file_ateapi_proto_rawDescGZIP(), []int{10} } func (x *HttpRule) GetHostnames() []string { @@ -1467,7 +1522,7 @@ type HttpsRule struct { func (x *HttpsRule) Reset() { *x = HttpsRule{} - mi := &file_ateapi_proto_msgTypes[10] + mi := &file_ateapi_proto_msgTypes[11] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1479,7 +1534,7 @@ func (x *HttpsRule) String() string { func (*HttpsRule) ProtoMessage() {} func (x *HttpsRule) 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 { @@ -1492,7 +1547,7 @@ func (x *HttpsRule) ProtoReflect() protoreflect.Message { // Deprecated: Use HttpsRule.ProtoReflect.Descriptor instead. func (*HttpsRule) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{10} + return file_ateapi_proto_rawDescGZIP(), []int{11} } func (x *HttpsRule) GetHostnames() []string { @@ -1543,7 +1598,7 @@ type TlsPassthroughRule struct { func (x *TlsPassthroughRule) Reset() { *x = TlsPassthroughRule{} - mi := &file_ateapi_proto_msgTypes[11] + mi := &file_ateapi_proto_msgTypes[12] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1555,7 +1610,7 @@ func (x *TlsPassthroughRule) String() string { func (*TlsPassthroughRule) ProtoMessage() {} func (x *TlsPassthroughRule) 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 { @@ -1568,7 +1623,7 @@ func (x *TlsPassthroughRule) ProtoReflect() protoreflect.Message { // Deprecated: Use TlsPassthroughRule.ProtoReflect.Descriptor instead. func (*TlsPassthroughRule) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{11} + return file_ateapi_proto_rawDescGZIP(), []int{12} } func (x *TlsPassthroughRule) GetHostnames() []string { @@ -1609,7 +1664,7 @@ type Ports struct { func (x *Ports) Reset() { *x = Ports{} - mi := &file_ateapi_proto_msgTypes[12] + mi := &file_ateapi_proto_msgTypes[13] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1621,7 +1676,7 @@ func (x *Ports) String() string { func (*Ports) ProtoMessage() {} func (x *Ports) 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 { @@ -1634,7 +1689,7 @@ func (x *Ports) ProtoReflect() protoreflect.Message { // Deprecated: Use Ports.ProtoReflect.Descriptor instead. func (*Ports) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{12} + return file_ateapi_proto_rawDescGZIP(), []int{13} } func (x *Ports) GetAll() *AllPorts { @@ -1660,7 +1715,7 @@ type AllPorts struct { func (x *AllPorts) Reset() { *x = AllPorts{} - mi := &file_ateapi_proto_msgTypes[13] + mi := &file_ateapi_proto_msgTypes[14] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1672,7 +1727,7 @@ func (x *AllPorts) String() string { func (*AllPorts) ProtoMessage() {} func (x *AllPorts) 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 { @@ -1685,7 +1740,7 @@ func (x *AllPorts) ProtoReflect() protoreflect.Message { // Deprecated: Use AllPorts.ProtoReflect.Descriptor instead. func (*AllPorts) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{13} + return file_ateapi_proto_rawDescGZIP(), []int{14} } // HttpRuleEffects contains effects applied by a matching HTTP or HTTPS rule. @@ -1719,7 +1774,7 @@ type HttpRuleEffects struct { func (x *HttpRuleEffects) Reset() { *x = HttpRuleEffects{} - mi := &file_ateapi_proto_msgTypes[14] + mi := &file_ateapi_proto_msgTypes[15] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1731,7 +1786,7 @@ func (x *HttpRuleEffects) String() string { func (*HttpRuleEffects) ProtoMessage() {} func (x *HttpRuleEffects) 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 { @@ -1744,7 +1799,7 @@ func (x *HttpRuleEffects) ProtoReflect() protoreflect.Message { // Deprecated: Use HttpRuleEffects.ProtoReflect.Descriptor instead. func (*HttpRuleEffects) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{14} + return file_ateapi_proto_rawDescGZIP(), []int{15} } func (x *HttpRuleEffects) GetReplaceHeaders() []*CredentialHeader { @@ -1794,7 +1849,7 @@ type CredentialHeader struct { func (x *CredentialHeader) Reset() { *x = CredentialHeader{} - mi := &file_ateapi_proto_msgTypes[15] + mi := &file_ateapi_proto_msgTypes[16] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1806,7 +1861,7 @@ func (x *CredentialHeader) String() string { func (*CredentialHeader) ProtoMessage() {} func (x *CredentialHeader) 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 { @@ -1819,7 +1874,7 @@ func (x *CredentialHeader) ProtoReflect() protoreflect.Message { // Deprecated: Use CredentialHeader.ProtoReflect.Descriptor instead. func (*CredentialHeader) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{15} + return file_ateapi_proto_rawDescGZIP(), []int{16} } func (x *CredentialHeader) GetHeader() string { @@ -1876,7 +1931,7 @@ type ActorJwtSource struct { func (x *ActorJwtSource) Reset() { *x = ActorJwtSource{} - mi := &file_ateapi_proto_msgTypes[16] + mi := &file_ateapi_proto_msgTypes[17] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1888,7 +1943,7 @@ func (x *ActorJwtSource) String() string { func (*ActorJwtSource) ProtoMessage() {} func (x *ActorJwtSource) 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 { @@ -1901,7 +1956,7 @@ func (x *ActorJwtSource) ProtoReflect() protoreflect.Message { // Deprecated: Use ActorJwtSource.ProtoReflect.Descriptor instead. func (*ActorJwtSource) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{16} + return file_ateapi_proto_rawDescGZIP(), []int{17} } func (x *ActorJwtSource) GetAudiences() []string { @@ -1978,7 +2033,7 @@ type ActorStatus struct { func (x *ActorStatus) Reset() { *x = ActorStatus{} - mi := &file_ateapi_proto_msgTypes[17] + mi := &file_ateapi_proto_msgTypes[18] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1990,7 +2045,7 @@ func (x *ActorStatus) String() string { func (*ActorStatus) ProtoMessage() {} func (x *ActorStatus) 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 { @@ -2003,7 +2058,7 @@ func (x *ActorStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use ActorStatus.ProtoReflect.Descriptor instead. func (*ActorStatus) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{17} + return file_ateapi_proto_rawDescGZIP(), []int{18} } func (x *ActorStatus) GetState() ActorState { @@ -2073,7 +2128,7 @@ type ActorCrash struct { func (x *ActorCrash) Reset() { *x = ActorCrash{} - mi := &file_ateapi_proto_msgTypes[18] + mi := &file_ateapi_proto_msgTypes[19] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2085,7 +2140,7 @@ func (x *ActorCrash) String() string { func (*ActorCrash) ProtoMessage() {} func (x *ActorCrash) 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 { @@ -2098,7 +2153,7 @@ func (x *ActorCrash) ProtoReflect() protoreflect.Message { // Deprecated: Use ActorCrash.ProtoReflect.Descriptor instead. func (*ActorCrash) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{18} + return file_ateapi_proto_rawDescGZIP(), []int{19} } func (x *ActorCrash) GetMessage() string { @@ -2184,7 +2239,7 @@ type WorkerAssignment struct { func (x *WorkerAssignment) Reset() { *x = WorkerAssignment{} - mi := &file_ateapi_proto_msgTypes[19] + mi := &file_ateapi_proto_msgTypes[20] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2196,7 +2251,7 @@ func (x *WorkerAssignment) String() string { func (*WorkerAssignment) ProtoMessage() {} func (x *WorkerAssignment) 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 { @@ -2209,7 +2264,7 @@ func (x *WorkerAssignment) ProtoReflect() protoreflect.Message { // Deprecated: Use WorkerAssignment.ProtoReflect.Descriptor instead. func (*WorkerAssignment) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{19} + return file_ateapi_proto_rawDescGZIP(), []int{20} } func (x *WorkerAssignment) GetWorker() *ObjectRef { @@ -2302,7 +2357,7 @@ type TagStatus struct { func (x *TagStatus) Reset() { *x = TagStatus{} - mi := &file_ateapi_proto_msgTypes[20] + mi := &file_ateapi_proto_msgTypes[21] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2314,7 +2369,7 @@ func (x *TagStatus) String() string { func (*TagStatus) ProtoMessage() {} func (x *TagStatus) 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 { @@ -2327,7 +2382,7 @@ func (x *TagStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use TagStatus.ProtoReflect.Descriptor instead. func (*TagStatus) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{20} + return file_ateapi_proto_rawDescGZIP(), []int{21} } func (x *TagStatus) GetSnapshot() *Snapshot { @@ -2379,7 +2434,7 @@ type Tag struct { func (x *Tag) Reset() { *x = Tag{} - mi := &file_ateapi_proto_msgTypes[21] + mi := &file_ateapi_proto_msgTypes[22] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2391,7 +2446,7 @@ func (x *Tag) String() string { func (*Tag) ProtoMessage() {} func (x *Tag) 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 { @@ -2404,7 +2459,7 @@ func (x *Tag) ProtoReflect() protoreflect.Message { // Deprecated: Use Tag.ProtoReflect.Descriptor instead. func (*Tag) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{21} + return file_ateapi_proto_rawDescGZIP(), []int{22} } func (x *Tag) GetMetadata() *ResourceMetadata { @@ -2450,7 +2505,7 @@ type Atespace struct { func (x *Atespace) Reset() { *x = Atespace{} - mi := &file_ateapi_proto_msgTypes[22] + mi := &file_ateapi_proto_msgTypes[23] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2462,7 +2517,7 @@ func (x *Atespace) String() string { func (*Atespace) ProtoMessage() {} func (x *Atespace) 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 { @@ -2475,7 +2530,7 @@ func (x *Atespace) ProtoReflect() protoreflect.Message { // Deprecated: Use Atespace.ProtoReflect.Descriptor instead. func (*Atespace) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{22} + return file_ateapi_proto_rawDescGZIP(), []int{23} } func (x *Atespace) GetMetadata() *ResourceMetadata { @@ -2508,7 +2563,7 @@ type ObjectRef struct { func (x *ObjectRef) Reset() { *x = ObjectRef{} - mi := &file_ateapi_proto_msgTypes[23] + mi := &file_ateapi_proto_msgTypes[24] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2520,7 +2575,7 @@ func (x *ObjectRef) String() string { func (*ObjectRef) ProtoMessage() {} func (x *ObjectRef) 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 { @@ -2533,7 +2588,7 @@ func (x *ObjectRef) ProtoReflect() protoreflect.Message { // Deprecated: Use ObjectRef.ProtoReflect.Descriptor instead. func (*ObjectRef) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{23} + return file_ateapi_proto_rawDescGZIP(), []int{24} } func (x *ObjectRef) GetAtespace() string { @@ -2586,14 +2641,25 @@ type ActorTemplate struct { // +k8s:customValidation # cpu and memory limits are both set Resources *Resources `protobuf:"bytes,7,opt,name=resources,proto3" json:"resources,omitempty"` // +k8s:optional - Status *ActorTemplateStatus `protobuf:"bytes,8,opt,name=status,proto3" json:"status,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache + Status *ActorTemplateStatus `protobuf:"bytes,8,opt,name=status,proto3" json:"status,omitempty"` + // Egress policy for the golden Actor during initialization. The template + // controller supplies a policy with these rules and generated metadata + // as CreateActorRequest.initial_egress_policy + // when creating the golden Actor. Other Actors created from this template + // do not inherit this policy, including when using the golden snapshot. + // If absent, no policy is created. When set, at least one rule is required. + // + // +ate:preview=GoldenEgressPolicy + // +k8s:ifDisabled(GoldenEgressPolicy)=+k8s:forbidden + // +k8s:optional + GoldenEgressPolicy *EgressPolicyTemplate `protobuf:"bytes,9,opt,name=golden_egress_policy,json=goldenEgressPolicy,proto3" json:"golden_egress_policy,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *ActorTemplate) Reset() { *x = ActorTemplate{} - mi := &file_ateapi_proto_msgTypes[24] + mi := &file_ateapi_proto_msgTypes[25] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2605,7 +2671,7 @@ func (x *ActorTemplate) String() string { func (*ActorTemplate) ProtoMessage() {} func (x *ActorTemplate) 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 { @@ -2618,7 +2684,7 @@ func (x *ActorTemplate) ProtoReflect() protoreflect.Message { // Deprecated: Use ActorTemplate.ProtoReflect.Descriptor instead. func (*ActorTemplate) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{24} + return file_ateapi_proto_rawDescGZIP(), []int{25} } func (x *ActorTemplate) GetMetadata() *ResourceMetadata { @@ -2677,6 +2743,13 @@ func (x *ActorTemplate) GetStatus() *ActorTemplateStatus { return nil } +func (x *ActorTemplate) GetGoldenEgressPolicy() *EgressPolicyTemplate { + if x != nil { + return x.GoldenEgressPolicy + } + return nil +} + type Resources struct { state protoimpl.MessageState `protogen:"open.v1"` // limits is the maximum amount of compute resources allowed. Only "cpu" @@ -2694,7 +2767,7 @@ type Resources struct { func (x *Resources) Reset() { *x = Resources{} - mi := &file_ateapi_proto_msgTypes[25] + mi := &file_ateapi_proto_msgTypes[26] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2706,7 +2779,7 @@ func (x *Resources) String() string { func (*Resources) ProtoMessage() {} func (x *Resources) 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 { @@ -2719,7 +2792,7 @@ func (x *Resources) ProtoReflect() protoreflect.Message { // Deprecated: Use Resources.ProtoReflect.Descriptor instead. func (*Resources) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{25} + return file_ateapi_proto_rawDescGZIP(), []int{26} } func (x *Resources) GetLimits() []*Limits { @@ -2747,7 +2820,7 @@ type Limits struct { func (x *Limits) Reset() { *x = Limits{} - mi := &file_ateapi_proto_msgTypes[26] + mi := &file_ateapi_proto_msgTypes[27] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2759,7 +2832,7 @@ func (x *Limits) String() string { func (*Limits) ProtoMessage() {} func (x *Limits) 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 { @@ -2772,7 +2845,7 @@ func (x *Limits) ProtoReflect() protoreflect.Message { // Deprecated: Use Limits.ProtoReflect.Descriptor instead. func (*Limits) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{26} + return file_ateapi_proto_rawDescGZIP(), []int{27} } func (x *Limits) GetName() string { @@ -2813,7 +2886,7 @@ type GoldenSnapshotStatus struct { func (x *GoldenSnapshotStatus) Reset() { *x = GoldenSnapshotStatus{} - mi := &file_ateapi_proto_msgTypes[27] + mi := &file_ateapi_proto_msgTypes[28] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2825,7 +2898,7 @@ func (x *GoldenSnapshotStatus) String() string { func (*GoldenSnapshotStatus) ProtoMessage() {} func (x *GoldenSnapshotStatus) 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 { @@ -2838,7 +2911,7 @@ func (x *GoldenSnapshotStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use GoldenSnapshotStatus.ProtoReflect.Descriptor instead. func (*GoldenSnapshotStatus) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{27} + return file_ateapi_proto_rawDescGZIP(), []int{28} } func (x *GoldenSnapshotStatus) GetGoldenTag() *ObjectRef { @@ -2872,7 +2945,7 @@ type ActorTemplateStatus struct { func (x *ActorTemplateStatus) Reset() { *x = ActorTemplateStatus{} - mi := &file_ateapi_proto_msgTypes[28] + mi := &file_ateapi_proto_msgTypes[29] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2884,7 +2957,7 @@ func (x *ActorTemplateStatus) String() string { func (*ActorTemplateStatus) ProtoMessage() {} func (x *ActorTemplateStatus) 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 { @@ -2897,7 +2970,7 @@ func (x *ActorTemplateStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use ActorTemplateStatus.ProtoReflect.Descriptor instead. func (*ActorTemplateStatus) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{28} + return file_ateapi_proto_rawDescGZIP(), []int{29} } func (x *ActorTemplateStatus) GetGoldenSnapshotStatus() *GoldenSnapshotStatus { @@ -2929,7 +3002,7 @@ type SandboxConfig struct { func (x *SandboxConfig) Reset() { *x = SandboxConfig{} - mi := &file_ateapi_proto_msgTypes[29] + mi := &file_ateapi_proto_msgTypes[30] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2941,7 +3014,7 @@ func (x *SandboxConfig) String() string { func (*SandboxConfig) ProtoMessage() {} func (x *SandboxConfig) 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 { @@ -2954,7 +3027,7 @@ func (x *SandboxConfig) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxConfig.ProtoReflect.Descriptor instead. func (*SandboxConfig) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{29} + return file_ateapi_proto_rawDescGZIP(), []int{30} } func (x *SandboxConfig) GetSandboxClass() string { @@ -3007,7 +3080,7 @@ type SnapshotConfig struct { func (x *SnapshotConfig) Reset() { *x = SnapshotConfig{} - mi := &file_ateapi_proto_msgTypes[30] + mi := &file_ateapi_proto_msgTypes[31] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3019,7 +3092,7 @@ func (x *SnapshotConfig) String() string { func (*SnapshotConfig) ProtoMessage() {} func (x *SnapshotConfig) 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 { @@ -3032,7 +3105,7 @@ func (x *SnapshotConfig) ProtoReflect() protoreflect.Message { // Deprecated: Use SnapshotConfig.ProtoReflect.Descriptor instead. func (*SnapshotConfig) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{30} + return file_ateapi_proto_rawDescGZIP(), []int{31} } func (x *SnapshotConfig) GetStorageLocation() string { @@ -3072,7 +3145,7 @@ type GoldenSnapshotConfig struct { func (x *GoldenSnapshotConfig) Reset() { *x = GoldenSnapshotConfig{} - mi := &file_ateapi_proto_msgTypes[31] + mi := &file_ateapi_proto_msgTypes[32] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3084,7 +3157,7 @@ func (x *GoldenSnapshotConfig) String() string { func (*GoldenSnapshotConfig) ProtoMessage() {} func (x *GoldenSnapshotConfig) 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 { @@ -3097,7 +3170,7 @@ func (x *GoldenSnapshotConfig) ProtoReflect() protoreflect.Message { // Deprecated: Use GoldenSnapshotConfig.ProtoReflect.Descriptor instead. func (*GoldenSnapshotConfig) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{31} + return file_ateapi_proto_rawDescGZIP(), []int{32} } func (x *GoldenSnapshotConfig) GetMode() GoldenSnapshotMode { @@ -3177,7 +3250,7 @@ type Container struct { func (x *Container) Reset() { *x = Container{} - mi := &file_ateapi_proto_msgTypes[32] + mi := &file_ateapi_proto_msgTypes[33] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3189,7 +3262,7 @@ func (x *Container) String() string { func (*Container) ProtoMessage() {} func (x *Container) 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 { @@ -3202,7 +3275,7 @@ func (x *Container) ProtoReflect() protoreflect.Message { // Deprecated: Use Container.ProtoReflect.Descriptor instead. func (*Container) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{32} + return file_ateapi_proto_rawDescGZIP(), []int{33} } func (x *Container) GetName() string { @@ -3282,7 +3355,7 @@ type SecurityContext struct { func (x *SecurityContext) Reset() { *x = SecurityContext{} - mi := &file_ateapi_proto_msgTypes[33] + mi := &file_ateapi_proto_msgTypes[34] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3294,7 +3367,7 @@ func (x *SecurityContext) String() string { func (*SecurityContext) ProtoMessage() {} func (x *SecurityContext) 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 { @@ -3307,7 +3380,7 @@ func (x *SecurityContext) ProtoReflect() protoreflect.Message { // Deprecated: Use SecurityContext.ProtoReflect.Descriptor instead. func (*SecurityContext) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{33} + return file_ateapi_proto_rawDescGZIP(), []int{34} } func (x *SecurityContext) GetCapabilities() *Capabilities { @@ -3345,7 +3418,7 @@ type Capabilities struct { func (x *Capabilities) Reset() { *x = Capabilities{} - mi := &file_ateapi_proto_msgTypes[34] + mi := &file_ateapi_proto_msgTypes[35] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3357,7 +3430,7 @@ func (x *Capabilities) String() string { func (*Capabilities) ProtoMessage() {} func (x *Capabilities) 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 { @@ -3370,7 +3443,7 @@ func (x *Capabilities) ProtoReflect() protoreflect.Message { // Deprecated: Use Capabilities.ProtoReflect.Descriptor instead. func (*Capabilities) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{34} + return file_ateapi_proto_rawDescGZIP(), []int{35} } func (x *Capabilities) GetAdd() []string { @@ -3408,7 +3481,7 @@ type EnvVar struct { func (x *EnvVar) Reset() { *x = EnvVar{} - mi := &file_ateapi_proto_msgTypes[35] + mi := &file_ateapi_proto_msgTypes[36] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3420,7 +3493,7 @@ func (x *EnvVar) String() string { func (*EnvVar) ProtoMessage() {} func (x *EnvVar) 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 { @@ -3433,7 +3506,7 @@ func (x *EnvVar) ProtoReflect() protoreflect.Message { // Deprecated: Use EnvVar.ProtoReflect.Descriptor instead. func (*EnvVar) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{35} + return file_ateapi_proto_rawDescGZIP(), []int{36} } func (x *EnvVar) GetName() string { @@ -3473,7 +3546,7 @@ type WakeupProbe struct { func (x *WakeupProbe) Reset() { *x = WakeupProbe{} - mi := &file_ateapi_proto_msgTypes[36] + mi := &file_ateapi_proto_msgTypes[37] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3485,7 +3558,7 @@ func (x *WakeupProbe) String() string { func (*WakeupProbe) ProtoMessage() {} func (x *WakeupProbe) 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 { @@ -3498,7 +3571,7 @@ func (x *WakeupProbe) ProtoReflect() protoreflect.Message { // Deprecated: Use WakeupProbe.ProtoReflect.Descriptor instead. func (*WakeupProbe) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{36} + return file_ateapi_proto_rawDescGZIP(), []int{37} } func (x *WakeupProbe) GetHttpGet() *HttpGetAction { @@ -3538,7 +3611,7 @@ type HttpGetAction struct { func (x *HttpGetAction) Reset() { *x = HttpGetAction{} - mi := &file_ateapi_proto_msgTypes[37] + mi := &file_ateapi_proto_msgTypes[38] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3550,7 +3623,7 @@ func (x *HttpGetAction) String() string { func (*HttpGetAction) ProtoMessage() {} func (x *HttpGetAction) 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 { @@ -3563,7 +3636,7 @@ func (x *HttpGetAction) ProtoReflect() protoreflect.Message { // Deprecated: Use HttpGetAction.ProtoReflect.Descriptor instead. func (*HttpGetAction) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{37} + return file_ateapi_proto_rawDescGZIP(), []int{38} } func (x *HttpGetAction) GetPath() string { @@ -3612,7 +3685,7 @@ type Volume struct { func (x *Volume) Reset() { *x = Volume{} - mi := &file_ateapi_proto_msgTypes[38] + mi := &file_ateapi_proto_msgTypes[39] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3624,7 +3697,7 @@ func (x *Volume) String() string { func (*Volume) ProtoMessage() {} func (x *Volume) 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 { @@ -3637,7 +3710,7 @@ func (x *Volume) ProtoReflect() protoreflect.Message { // Deprecated: Use Volume.ProtoReflect.Descriptor instead. func (*Volume) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{38} + return file_ateapi_proto_rawDescGZIP(), []int{39} } func (x *Volume) GetName() string { @@ -3693,7 +3766,7 @@ type ImageVolumeSource struct { func (x *ImageVolumeSource) Reset() { *x = ImageVolumeSource{} - mi := &file_ateapi_proto_msgTypes[39] + mi := &file_ateapi_proto_msgTypes[40] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3705,7 +3778,7 @@ func (x *ImageVolumeSource) String() string { func (*ImageVolumeSource) ProtoMessage() {} func (x *ImageVolumeSource) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[39] + mi := &file_ateapi_proto_msgTypes[40] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3718,7 +3791,7 @@ func (x *ImageVolumeSource) ProtoReflect() protoreflect.Message { // Deprecated: Use ImageVolumeSource.ProtoReflect.Descriptor instead. func (*ImageVolumeSource) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{39} + return file_ateapi_proto_rawDescGZIP(), []int{40} } func (x *ImageVolumeSource) GetReference() string { @@ -3738,7 +3811,7 @@ type DurableDirVolumeSource struct { func (x *DurableDirVolumeSource) Reset() { *x = DurableDirVolumeSource{} - mi := &file_ateapi_proto_msgTypes[40] + mi := &file_ateapi_proto_msgTypes[41] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3750,7 +3823,7 @@ func (x *DurableDirVolumeSource) String() string { func (*DurableDirVolumeSource) ProtoMessage() {} func (x *DurableDirVolumeSource) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[40] + mi := &file_ateapi_proto_msgTypes[41] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3763,7 +3836,7 @@ func (x *DurableDirVolumeSource) ProtoReflect() protoreflect.Message { // Deprecated: Use DurableDirVolumeSource.ProtoReflect.Descriptor instead. func (*DurableDirVolumeSource) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{40} + return file_ateapi_proto_rawDescGZIP(), []int{41} } // ExternalVolumeTemplate provisions an external volume per actor; the volume @@ -3789,7 +3862,7 @@ type ExternalVolumeTemplate struct { func (x *ExternalVolumeTemplate) Reset() { *x = ExternalVolumeTemplate{} - mi := &file_ateapi_proto_msgTypes[41] + mi := &file_ateapi_proto_msgTypes[42] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3801,7 +3874,7 @@ func (x *ExternalVolumeTemplate) String() string { func (*ExternalVolumeTemplate) ProtoMessage() {} func (x *ExternalVolumeTemplate) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[41] + mi := &file_ateapi_proto_msgTypes[42] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3814,7 +3887,7 @@ func (x *ExternalVolumeTemplate) ProtoReflect() protoreflect.Message { // Deprecated: Use ExternalVolumeTemplate.ProtoReflect.Descriptor instead. func (*ExternalVolumeTemplate) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{41} + return file_ateapi_proto_rawDescGZIP(), []int{42} } func (x *ExternalVolumeTemplate) GetCapacity() string { @@ -3851,7 +3924,7 @@ type SystemInfoVolumeSource struct { func (x *SystemInfoVolumeSource) Reset() { *x = SystemInfoVolumeSource{} - mi := &file_ateapi_proto_msgTypes[42] + mi := &file_ateapi_proto_msgTypes[43] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3863,7 +3936,7 @@ func (x *SystemInfoVolumeSource) String() string { func (*SystemInfoVolumeSource) ProtoMessage() {} func (x *SystemInfoVolumeSource) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[42] + mi := &file_ateapi_proto_msgTypes[43] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3876,7 +3949,7 @@ func (x *SystemInfoVolumeSource) ProtoReflect() protoreflect.Message { // Deprecated: Use SystemInfoVolumeSource.ProtoReflect.Descriptor instead. func (*SystemInfoVolumeSource) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{42} + return file_ateapi_proto_rawDescGZIP(), []int{43} } func (x *SystemInfoVolumeSource) GetDataSources() []*SystemInfoDataSource { @@ -3902,7 +3975,7 @@ type SystemInfoDataSource struct { func (x *SystemInfoDataSource) Reset() { *x = SystemInfoDataSource{} - mi := &file_ateapi_proto_msgTypes[43] + mi := &file_ateapi_proto_msgTypes[44] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3914,7 +3987,7 @@ func (x *SystemInfoDataSource) String() string { func (*SystemInfoDataSource) ProtoMessage() {} func (x *SystemInfoDataSource) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[43] + mi := &file_ateapi_proto_msgTypes[44] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3927,7 +4000,7 @@ func (x *SystemInfoDataSource) ProtoReflect() protoreflect.Message { // Deprecated: Use SystemInfoDataSource.ProtoReflect.Descriptor instead. func (*SystemInfoDataSource) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{43} + return file_ateapi_proto_rawDescGZIP(), []int{44} } func (x *SystemInfoDataSource) GetActorMetadata() *ActorMetadataDataSource { @@ -3964,7 +4037,7 @@ type ActorMetadataDataSource struct { func (x *ActorMetadataDataSource) Reset() { *x = ActorMetadataDataSource{} - mi := &file_ateapi_proto_msgTypes[44] + mi := &file_ateapi_proto_msgTypes[45] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3976,7 +4049,7 @@ func (x *ActorMetadataDataSource) String() string { func (*ActorMetadataDataSource) ProtoMessage() {} func (x *ActorMetadataDataSource) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[44] + mi := &file_ateapi_proto_msgTypes[45] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3989,7 +4062,7 @@ func (x *ActorMetadataDataSource) ProtoReflect() protoreflect.Message { // Deprecated: Use ActorMetadataDataSource.ProtoReflect.Descriptor instead. func (*ActorMetadataDataSource) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{44} + return file_ateapi_proto_rawDescGZIP(), []int{45} } func (x *ActorMetadataDataSource) GetItems() []*ActorMetadataItem { @@ -4021,7 +4094,7 @@ type ActorMetadataItem struct { func (x *ActorMetadataItem) Reset() { *x = ActorMetadataItem{} - mi := &file_ateapi_proto_msgTypes[45] + mi := &file_ateapi_proto_msgTypes[46] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4033,7 +4106,7 @@ func (x *ActorMetadataItem) String() string { func (*ActorMetadataItem) ProtoMessage() {} func (x *ActorMetadataItem) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[45] + mi := &file_ateapi_proto_msgTypes[46] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4046,7 +4119,7 @@ func (x *ActorMetadataItem) ProtoReflect() protoreflect.Message { // Deprecated: Use ActorMetadataItem.ProtoReflect.Descriptor instead. func (*ActorMetadataItem) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{45} + return file_ateapi_proto_rawDescGZIP(), []int{46} } func (x *ActorMetadataItem) GetField() ActorMetadataField { @@ -4098,7 +4171,7 @@ type TrustBundleDataSource struct { func (x *TrustBundleDataSource) Reset() { *x = TrustBundleDataSource{} - mi := &file_ateapi_proto_msgTypes[46] + mi := &file_ateapi_proto_msgTypes[47] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4110,7 +4183,7 @@ func (x *TrustBundleDataSource) String() string { func (*TrustBundleDataSource) ProtoMessage() {} func (x *TrustBundleDataSource) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[46] + mi := &file_ateapi_proto_msgTypes[47] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4123,7 +4196,7 @@ func (x *TrustBundleDataSource) ProtoReflect() protoreflect.Message { // Deprecated: Use TrustBundleDataSource.ProtoReflect.Descriptor instead. func (*TrustBundleDataSource) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{46} + return file_ateapi_proto_rawDescGZIP(), []int{47} } func (x *TrustBundleDataSource) GetNames() []string { @@ -4162,7 +4235,7 @@ type VolumeMount struct { func (x *VolumeMount) Reset() { *x = VolumeMount{} - mi := &file_ateapi_proto_msgTypes[47] + mi := &file_ateapi_proto_msgTypes[48] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4174,7 +4247,7 @@ func (x *VolumeMount) String() string { func (*VolumeMount) ProtoMessage() {} func (x *VolumeMount) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[47] + mi := &file_ateapi_proto_msgTypes[48] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4187,7 +4260,7 @@ func (x *VolumeMount) ProtoReflect() protoreflect.Message { // Deprecated: Use VolumeMount.ProtoReflect.Descriptor instead. func (*VolumeMount) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{47} + return file_ateapi_proto_rawDescGZIP(), []int{48} } func (x *VolumeMount) GetName() string { @@ -4216,7 +4289,7 @@ type CreateAtespaceRequest struct { func (x *CreateAtespaceRequest) Reset() { *x = CreateAtespaceRequest{} - mi := &file_ateapi_proto_msgTypes[48] + mi := &file_ateapi_proto_msgTypes[49] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4228,7 +4301,7 @@ func (x *CreateAtespaceRequest) String() string { func (*CreateAtespaceRequest) ProtoMessage() {} func (x *CreateAtespaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[48] + mi := &file_ateapi_proto_msgTypes[49] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4241,7 +4314,7 @@ func (x *CreateAtespaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateAtespaceRequest.ProtoReflect.Descriptor instead. func (*CreateAtespaceRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{48} + return file_ateapi_proto_rawDescGZIP(), []int{49} } func (x *CreateAtespaceRequest) GetAtespace() *Atespace { @@ -4262,7 +4335,7 @@ type GetAtespaceRequest struct { func (x *GetAtespaceRequest) Reset() { *x = GetAtespaceRequest{} - mi := &file_ateapi_proto_msgTypes[49] + mi := &file_ateapi_proto_msgTypes[50] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4274,7 +4347,7 @@ func (x *GetAtespaceRequest) String() string { func (*GetAtespaceRequest) ProtoMessage() {} func (x *GetAtespaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[49] + mi := &file_ateapi_proto_msgTypes[50] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4287,7 +4360,7 @@ func (x *GetAtespaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetAtespaceRequest.ProtoReflect.Descriptor instead. func (*GetAtespaceRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{49} + return file_ateapi_proto_rawDescGZIP(), []int{50} } func (x *GetAtespaceRequest) GetAtespace() *ObjectRef { @@ -4309,7 +4382,7 @@ type ListAtespacesRequest struct { func (x *ListAtespacesRequest) Reset() { *x = ListAtespacesRequest{} - mi := &file_ateapi_proto_msgTypes[50] + mi := &file_ateapi_proto_msgTypes[51] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4321,7 +4394,7 @@ func (x *ListAtespacesRequest) String() string { func (*ListAtespacesRequest) ProtoMessage() {} func (x *ListAtespacesRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[50] + mi := &file_ateapi_proto_msgTypes[51] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4334,7 +4407,7 @@ func (x *ListAtespacesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListAtespacesRequest.ProtoReflect.Descriptor instead. func (*ListAtespacesRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{50} + return file_ateapi_proto_rawDescGZIP(), []int{51} } func (x *ListAtespacesRequest) GetOptions() *ListOptions { @@ -4356,7 +4429,7 @@ type ListAtespacesResponse struct { func (x *ListAtespacesResponse) Reset() { *x = ListAtespacesResponse{} - mi := &file_ateapi_proto_msgTypes[51] + mi := &file_ateapi_proto_msgTypes[52] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4368,7 +4441,7 @@ func (x *ListAtespacesResponse) String() string { func (*ListAtespacesResponse) ProtoMessage() {} func (x *ListAtespacesResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[51] + mi := &file_ateapi_proto_msgTypes[52] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4381,7 +4454,7 @@ func (x *ListAtespacesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListAtespacesResponse.ProtoReflect.Descriptor instead. func (*ListAtespacesResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{51} + return file_ateapi_proto_rawDescGZIP(), []int{52} } func (x *ListAtespacesResponse) GetAtespaces() []*Atespace { @@ -4413,7 +4486,7 @@ type DeleteAtespaceRequest struct { func (x *DeleteAtespaceRequest) Reset() { *x = DeleteAtespaceRequest{} - mi := &file_ateapi_proto_msgTypes[52] + mi := &file_ateapi_proto_msgTypes[53] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4425,7 +4498,7 @@ func (x *DeleteAtespaceRequest) String() string { func (*DeleteAtespaceRequest) ProtoMessage() {} func (x *DeleteAtespaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[52] + mi := &file_ateapi_proto_msgTypes[53] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4438,7 +4511,7 @@ func (x *DeleteAtespaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteAtespaceRequest.ProtoReflect.Descriptor instead. func (*DeleteAtespaceRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{52} + return file_ateapi_proto_rawDescGZIP(), []int{53} } func (x *DeleteAtespaceRequest) GetAtespace() *ObjectRef { @@ -4469,7 +4542,7 @@ type CreateActorTemplateRequest struct { func (x *CreateActorTemplateRequest) Reset() { *x = CreateActorTemplateRequest{} - mi := &file_ateapi_proto_msgTypes[53] + mi := &file_ateapi_proto_msgTypes[54] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4481,7 +4554,7 @@ func (x *CreateActorTemplateRequest) String() string { func (*CreateActorTemplateRequest) ProtoMessage() {} func (x *CreateActorTemplateRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[53] + mi := &file_ateapi_proto_msgTypes[54] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4494,7 +4567,7 @@ func (x *CreateActorTemplateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateActorTemplateRequest.ProtoReflect.Descriptor instead. func (*CreateActorTemplateRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{53} + return file_ateapi_proto_rawDescGZIP(), []int{54} } func (x *CreateActorTemplateRequest) GetActorTemplate() *ActorTemplate { @@ -4515,7 +4588,7 @@ type GetActorTemplateRequest struct { func (x *GetActorTemplateRequest) Reset() { *x = GetActorTemplateRequest{} - mi := &file_ateapi_proto_msgTypes[54] + mi := &file_ateapi_proto_msgTypes[55] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4527,7 +4600,7 @@ func (x *GetActorTemplateRequest) String() string { func (*GetActorTemplateRequest) ProtoMessage() {} func (x *GetActorTemplateRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[54] + mi := &file_ateapi_proto_msgTypes[55] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4540,7 +4613,7 @@ func (x *GetActorTemplateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetActorTemplateRequest.ProtoReflect.Descriptor instead. func (*GetActorTemplateRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{54} + return file_ateapi_proto_rawDescGZIP(), []int{55} } func (x *GetActorTemplateRequest) GetActorTemplate() *ObjectRef { @@ -4568,7 +4641,7 @@ type ListActorTemplatesRequest struct { func (x *ListActorTemplatesRequest) Reset() { *x = ListActorTemplatesRequest{} - mi := &file_ateapi_proto_msgTypes[55] + mi := &file_ateapi_proto_msgTypes[56] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4580,7 +4653,7 @@ func (x *ListActorTemplatesRequest) String() string { func (*ListActorTemplatesRequest) ProtoMessage() {} func (x *ListActorTemplatesRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[55] + mi := &file_ateapi_proto_msgTypes[56] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4593,7 +4666,7 @@ func (x *ListActorTemplatesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListActorTemplatesRequest.ProtoReflect.Descriptor instead. func (*ListActorTemplatesRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{55} + return file_ateapi_proto_rawDescGZIP(), []int{56} } func (x *ListActorTemplatesRequest) GetAtespace() string { @@ -4623,7 +4696,7 @@ type ListActorTemplatesResponse struct { func (x *ListActorTemplatesResponse) Reset() { *x = ListActorTemplatesResponse{} - mi := &file_ateapi_proto_msgTypes[56] + mi := &file_ateapi_proto_msgTypes[57] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4635,7 +4708,7 @@ func (x *ListActorTemplatesResponse) String() string { func (*ListActorTemplatesResponse) ProtoMessage() {} func (x *ListActorTemplatesResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[56] + mi := &file_ateapi_proto_msgTypes[57] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4648,7 +4721,7 @@ func (x *ListActorTemplatesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListActorTemplatesResponse.ProtoReflect.Descriptor instead. func (*ListActorTemplatesResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{56} + return file_ateapi_proto_rawDescGZIP(), []int{57} } func (x *ListActorTemplatesResponse) GetActorTemplates() []*ActorTemplate { @@ -4680,7 +4753,7 @@ type DeleteActorTemplateRequest struct { func (x *DeleteActorTemplateRequest) Reset() { *x = DeleteActorTemplateRequest{} - mi := &file_ateapi_proto_msgTypes[57] + mi := &file_ateapi_proto_msgTypes[58] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4692,7 +4765,7 @@ func (x *DeleteActorTemplateRequest) String() string { func (*DeleteActorTemplateRequest) ProtoMessage() {} func (x *DeleteActorTemplateRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[57] + mi := &file_ateapi_proto_msgTypes[58] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4705,7 +4778,7 @@ func (x *DeleteActorTemplateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteActorTemplateRequest.ProtoReflect.Descriptor instead. func (*DeleteActorTemplateRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{57} + return file_ateapi_proto_rawDescGZIP(), []int{58} } func (x *DeleteActorTemplateRequest) GetActorTemplate() *ObjectRef { @@ -4733,7 +4806,7 @@ type GetActorRequest struct { func (x *GetActorRequest) Reset() { *x = GetActorRequest{} - mi := &file_ateapi_proto_msgTypes[58] + mi := &file_ateapi_proto_msgTypes[59] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4745,7 +4818,7 @@ func (x *GetActorRequest) String() string { func (*GetActorRequest) ProtoMessage() {} func (x *GetActorRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[58] + mi := &file_ateapi_proto_msgTypes[59] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4758,7 +4831,7 @@ func (x *GetActorRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetActorRequest.ProtoReflect.Descriptor instead. func (*GetActorRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{58} + return file_ateapi_proto_rawDescGZIP(), []int{59} } func (x *GetActorRequest) GetActor() *ObjectRef { @@ -4769,19 +4842,32 @@ func (x *GetActorRequest) GetActor() *ObjectRef { } // Request to create a new Actor. +// +// +k8s:customValidation # initial policy must match the actor's atespace and contain rules type CreateActorRequest struct { state protoimpl.MessageState `protogen:"open.v1"` // The actor to create. // // +k8s:required - Actor *Actor `protobuf:"bytes,1,opt,name=actor,proto3" json:"actor,omitempty"` - unknownFields protoimpl.UnknownFields - sizeCache protoimpl.SizeCache + Actor *Actor `protobuf:"bytes,1,opt,name=actor,proto3" json:"actor,omitempty"` + // Optional initial egress policy, created atomically with the Actor as its + // "default" policy. metadata.name must be "default" and metadata.atespace + // must match actor.metadata.atespace. UID, version, and timestamps are + // server-managed. When set, at least one rule is required, and the caller + // must have permission to create an egress policy on the Actor in addition + // to creating the Actor. + // If absent, no policy is created or inherited from the template or tag. + // The policy can subsequently be managed through the Actor egress policy RPCs. + // + // +k8s:optional + InitialEgressPolicy *EgressPolicy `protobuf:"bytes,2,opt,name=initial_egress_policy,json=initialEgressPolicy,proto3" json:"initial_egress_policy,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache } func (x *CreateActorRequest) Reset() { *x = CreateActorRequest{} - mi := &file_ateapi_proto_msgTypes[59] + mi := &file_ateapi_proto_msgTypes[60] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4793,7 +4879,7 @@ func (x *CreateActorRequest) String() string { func (*CreateActorRequest) ProtoMessage() {} func (x *CreateActorRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[59] + mi := &file_ateapi_proto_msgTypes[60] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4806,7 +4892,7 @@ func (x *CreateActorRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateActorRequest.ProtoReflect.Descriptor instead. func (*CreateActorRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{59} + return file_ateapi_proto_rawDescGZIP(), []int{60} } func (x *CreateActorRequest) GetActor() *Actor { @@ -4816,6 +4902,13 @@ func (x *CreateActorRequest) GetActor() *Actor { return nil } +func (x *CreateActorRequest) GetInitialEgressPolicy() *EgressPolicy { + if x != nil { + return x.InitialEgressPolicy + } + return nil +} + // Request to update mutable fields on an existing Actor. // May be called regardless of the actor's current state. // Changes take effect on the next ResumeActor call. @@ -4837,7 +4930,7 @@ type UpdateActorRequest struct { func (x *UpdateActorRequest) Reset() { *x = UpdateActorRequest{} - mi := &file_ateapi_proto_msgTypes[60] + mi := &file_ateapi_proto_msgTypes[61] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4849,7 +4942,7 @@ func (x *UpdateActorRequest) String() string { func (*UpdateActorRequest) ProtoMessage() {} func (x *UpdateActorRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[60] + mi := &file_ateapi_proto_msgTypes[61] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4862,7 +4955,7 @@ func (x *UpdateActorRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateActorRequest.ProtoReflect.Descriptor instead. func (*UpdateActorRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{60} + return file_ateapi_proto_rawDescGZIP(), []int{61} } func (x *UpdateActorRequest) GetActor() *Actor { @@ -4883,7 +4976,7 @@ type SuspendActorRequest struct { func (x *SuspendActorRequest) Reset() { *x = SuspendActorRequest{} - mi := &file_ateapi_proto_msgTypes[61] + mi := &file_ateapi_proto_msgTypes[62] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4895,7 +4988,7 @@ func (x *SuspendActorRequest) String() string { func (*SuspendActorRequest) ProtoMessage() {} func (x *SuspendActorRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[61] + mi := &file_ateapi_proto_msgTypes[62] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4908,7 +5001,7 @@ func (x *SuspendActorRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SuspendActorRequest.ProtoReflect.Descriptor instead. func (*SuspendActorRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{61} + return file_ateapi_proto_rawDescGZIP(), []int{62} } func (x *SuspendActorRequest) GetActor() *ObjectRef { @@ -4927,7 +5020,7 @@ type SuspendActorResponse struct { func (x *SuspendActorResponse) Reset() { *x = SuspendActorResponse{} - mi := &file_ateapi_proto_msgTypes[62] + mi := &file_ateapi_proto_msgTypes[63] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4939,7 +5032,7 @@ func (x *SuspendActorResponse) String() string { func (*SuspendActorResponse) ProtoMessage() {} func (x *SuspendActorResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[62] + mi := &file_ateapi_proto_msgTypes[63] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4952,7 +5045,7 @@ func (x *SuspendActorResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SuspendActorResponse.ProtoReflect.Descriptor instead. func (*SuspendActorResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{62} + return file_ateapi_proto_rawDescGZIP(), []int{63} } func (x *SuspendActorResponse) GetActor() *Actor { @@ -4973,7 +5066,7 @@ type PauseActorRequest struct { func (x *PauseActorRequest) Reset() { *x = PauseActorRequest{} - mi := &file_ateapi_proto_msgTypes[63] + mi := &file_ateapi_proto_msgTypes[64] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4985,7 +5078,7 @@ func (x *PauseActorRequest) String() string { func (*PauseActorRequest) ProtoMessage() {} func (x *PauseActorRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[63] + mi := &file_ateapi_proto_msgTypes[64] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4998,7 +5091,7 @@ func (x *PauseActorRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use PauseActorRequest.ProtoReflect.Descriptor instead. func (*PauseActorRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{63} + return file_ateapi_proto_rawDescGZIP(), []int{64} } func (x *PauseActorRequest) GetActor() *ObjectRef { @@ -5017,7 +5110,7 @@ type PauseActorResponse struct { func (x *PauseActorResponse) Reset() { *x = PauseActorResponse{} - mi := &file_ateapi_proto_msgTypes[64] + mi := &file_ateapi_proto_msgTypes[65] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5029,7 +5122,7 @@ func (x *PauseActorResponse) String() string { func (*PauseActorResponse) ProtoMessage() {} func (x *PauseActorResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[64] + mi := &file_ateapi_proto_msgTypes[65] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5042,7 +5135,7 @@ func (x *PauseActorResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use PauseActorResponse.ProtoReflect.Descriptor instead. func (*PauseActorResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{64} + return file_ateapi_proto_rawDescGZIP(), []int{65} } func (x *PauseActorResponse) GetActor() *Actor { @@ -5063,7 +5156,7 @@ type ResumeActorRequest struct { func (x *ResumeActorRequest) Reset() { *x = ResumeActorRequest{} - mi := &file_ateapi_proto_msgTypes[65] + mi := &file_ateapi_proto_msgTypes[66] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5075,7 +5168,7 @@ func (x *ResumeActorRequest) String() string { func (*ResumeActorRequest) ProtoMessage() {} func (x *ResumeActorRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[65] + mi := &file_ateapi_proto_msgTypes[66] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5088,7 +5181,7 @@ func (x *ResumeActorRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ResumeActorRequest.ProtoReflect.Descriptor instead. func (*ResumeActorRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{65} + return file_ateapi_proto_rawDescGZIP(), []int{66} } func (x *ResumeActorRequest) GetActor() *ObjectRef { @@ -5110,7 +5203,7 @@ type ResumeActorResponse struct { func (x *ResumeActorResponse) Reset() { *x = ResumeActorResponse{} - mi := &file_ateapi_proto_msgTypes[66] + mi := &file_ateapi_proto_msgTypes[67] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5122,7 +5215,7 @@ func (x *ResumeActorResponse) String() string { func (*ResumeActorResponse) ProtoMessage() {} func (x *ResumeActorResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[66] + mi := &file_ateapi_proto_msgTypes[67] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5135,7 +5228,7 @@ func (x *ResumeActorResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ResumeActorResponse.ProtoReflect.Descriptor instead. func (*ResumeActorResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{66} + return file_ateapi_proto_rawDescGZIP(), []int{67} } func (x *ResumeActorResponse) GetActor() *Actor { @@ -5165,7 +5258,7 @@ type RevertActorRequest struct { func (x *RevertActorRequest) Reset() { *x = RevertActorRequest{} - mi := &file_ateapi_proto_msgTypes[67] + mi := &file_ateapi_proto_msgTypes[68] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5177,7 +5270,7 @@ func (x *RevertActorRequest) String() string { func (*RevertActorRequest) ProtoMessage() {} func (x *RevertActorRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[67] + mi := &file_ateapi_proto_msgTypes[68] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5190,7 +5283,7 @@ func (x *RevertActorRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RevertActorRequest.ProtoReflect.Descriptor instead. func (*RevertActorRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{67} + return file_ateapi_proto_rawDescGZIP(), []int{68} } func (x *RevertActorRequest) GetActor() *ObjectRef { @@ -5212,7 +5305,7 @@ type RevertActorResponse struct { func (x *RevertActorResponse) Reset() { *x = RevertActorResponse{} - mi := &file_ateapi_proto_msgTypes[68] + mi := &file_ateapi_proto_msgTypes[69] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5224,7 +5317,7 @@ func (x *RevertActorResponse) String() string { func (*RevertActorResponse) ProtoMessage() {} func (x *RevertActorResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[68] + mi := &file_ateapi_proto_msgTypes[69] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5237,7 +5330,7 @@ func (x *RevertActorResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RevertActorResponse.ProtoReflect.Descriptor instead. func (*RevertActorResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{68} + return file_ateapi_proto_rawDescGZIP(), []int{69} } func (x *RevertActorResponse) GetActor() *Actor { @@ -5266,7 +5359,7 @@ type DeleteActorRequest struct { func (x *DeleteActorRequest) Reset() { *x = DeleteActorRequest{} - mi := &file_ateapi_proto_msgTypes[69] + mi := &file_ateapi_proto_msgTypes[70] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5278,7 +5371,7 @@ func (x *DeleteActorRequest) String() string { func (*DeleteActorRequest) ProtoMessage() {} func (x *DeleteActorRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[69] + mi := &file_ateapi_proto_msgTypes[70] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5291,7 +5384,7 @@ func (x *DeleteActorRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteActorRequest.ProtoReflect.Descriptor instead. func (*DeleteActorRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{69} + return file_ateapi_proto_rawDescGZIP(), []int{70} } func (x *DeleteActorRequest) GetActor() *ObjectRef { @@ -5335,7 +5428,7 @@ type GetActorEgressPolicyRequest struct { func (x *GetActorEgressPolicyRequest) Reset() { *x = GetActorEgressPolicyRequest{} - mi := &file_ateapi_proto_msgTypes[70] + mi := &file_ateapi_proto_msgTypes[71] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5347,7 +5440,7 @@ func (x *GetActorEgressPolicyRequest) String() string { func (*GetActorEgressPolicyRequest) ProtoMessage() {} func (x *GetActorEgressPolicyRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[70] + mi := &file_ateapi_proto_msgTypes[71] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5360,7 +5453,7 @@ func (x *GetActorEgressPolicyRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetActorEgressPolicyRequest.ProtoReflect.Descriptor instead. func (*GetActorEgressPolicyRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{70} + return file_ateapi_proto_rawDescGZIP(), []int{71} } func (x *GetActorEgressPolicyRequest) GetActor() *ObjectRef { @@ -5398,7 +5491,7 @@ type CreateActorEgressPolicyRequest struct { func (x *CreateActorEgressPolicyRequest) Reset() { *x = CreateActorEgressPolicyRequest{} - mi := &file_ateapi_proto_msgTypes[71] + mi := &file_ateapi_proto_msgTypes[72] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5410,7 +5503,7 @@ func (x *CreateActorEgressPolicyRequest) String() string { func (*CreateActorEgressPolicyRequest) ProtoMessage() {} func (x *CreateActorEgressPolicyRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[71] + mi := &file_ateapi_proto_msgTypes[72] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5423,7 +5516,7 @@ func (x *CreateActorEgressPolicyRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateActorEgressPolicyRequest.ProtoReflect.Descriptor instead. func (*CreateActorEgressPolicyRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{71} + return file_ateapi_proto_rawDescGZIP(), []int{72} } func (x *CreateActorEgressPolicyRequest) GetActor() *ObjectRef { @@ -5461,7 +5554,7 @@ type UpdateActorEgressPolicyRequest struct { func (x *UpdateActorEgressPolicyRequest) Reset() { *x = UpdateActorEgressPolicyRequest{} - mi := &file_ateapi_proto_msgTypes[72] + mi := &file_ateapi_proto_msgTypes[73] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5473,7 +5566,7 @@ func (x *UpdateActorEgressPolicyRequest) String() string { func (*UpdateActorEgressPolicyRequest) ProtoMessage() {} func (x *UpdateActorEgressPolicyRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[72] + mi := &file_ateapi_proto_msgTypes[73] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5486,7 +5579,7 @@ func (x *UpdateActorEgressPolicyRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateActorEgressPolicyRequest.ProtoReflect.Descriptor instead. func (*UpdateActorEgressPolicyRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{72} + return file_ateapi_proto_rawDescGZIP(), []int{73} } func (x *UpdateActorEgressPolicyRequest) GetActor() *ObjectRef { @@ -5527,7 +5620,7 @@ type DeleteActorEgressPolicyRequest struct { func (x *DeleteActorEgressPolicyRequest) Reset() { *x = DeleteActorEgressPolicyRequest{} - mi := &file_ateapi_proto_msgTypes[73] + mi := &file_ateapi_proto_msgTypes[74] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5539,7 +5632,7 @@ func (x *DeleteActorEgressPolicyRequest) String() string { func (*DeleteActorEgressPolicyRequest) ProtoMessage() {} func (x *DeleteActorEgressPolicyRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[73] + mi := &file_ateapi_proto_msgTypes[74] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5552,7 +5645,7 @@ func (x *DeleteActorEgressPolicyRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteActorEgressPolicyRequest.ProtoReflect.Descriptor instead. func (*DeleteActorEgressPolicyRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{73} + return file_ateapi_proto_rawDescGZIP(), []int{74} } func (x *DeleteActorEgressPolicyRequest) GetActor() *ObjectRef { @@ -5587,7 +5680,7 @@ type GetTagRequest struct { func (x *GetTagRequest) Reset() { *x = GetTagRequest{} - mi := &file_ateapi_proto_msgTypes[74] + mi := &file_ateapi_proto_msgTypes[75] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5599,7 +5692,7 @@ func (x *GetTagRequest) String() string { func (*GetTagRequest) ProtoMessage() {} func (x *GetTagRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[74] + mi := &file_ateapi_proto_msgTypes[75] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5612,7 +5705,7 @@ func (x *GetTagRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetTagRequest.ProtoReflect.Descriptor instead. func (*GetTagRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{74} + return file_ateapi_proto_rawDescGZIP(), []int{75} } func (x *GetTagRequest) GetTag() *ObjectRef { @@ -5651,7 +5744,7 @@ type MintActorJwtRequest struct { func (x *MintActorJwtRequest) Reset() { *x = MintActorJwtRequest{} - mi := &file_ateapi_proto_msgTypes[75] + mi := &file_ateapi_proto_msgTypes[76] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5663,7 +5756,7 @@ func (x *MintActorJwtRequest) String() string { func (*MintActorJwtRequest) ProtoMessage() {} func (x *MintActorJwtRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[75] + mi := &file_ateapi_proto_msgTypes[76] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5676,7 +5769,7 @@ func (x *MintActorJwtRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MintActorJwtRequest.ProtoReflect.Descriptor instead. func (*MintActorJwtRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{75} + return file_ateapi_proto_rawDescGZIP(), []int{76} } func (x *MintActorJwtRequest) GetActor() *ObjectRef { @@ -5731,7 +5824,7 @@ type MintActorJwtResponse struct { func (x *MintActorJwtResponse) Reset() { *x = MintActorJwtResponse{} - mi := &file_ateapi_proto_msgTypes[76] + mi := &file_ateapi_proto_msgTypes[77] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5743,7 +5836,7 @@ func (x *MintActorJwtResponse) String() string { func (*MintActorJwtResponse) ProtoMessage() {} func (x *MintActorJwtResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[76] + mi := &file_ateapi_proto_msgTypes[77] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5756,7 +5849,7 @@ func (x *MintActorJwtResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MintActorJwtResponse.ProtoReflect.Descriptor instead. func (*MintActorJwtResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{76} + return file_ateapi_proto_rawDescGZIP(), []int{77} } func (x *MintActorJwtResponse) GetActorJwt() string { @@ -5801,7 +5894,7 @@ type MintActorCertificateRequest struct { func (x *MintActorCertificateRequest) Reset() { *x = MintActorCertificateRequest{} - mi := &file_ateapi_proto_msgTypes[77] + mi := &file_ateapi_proto_msgTypes[78] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5813,7 +5906,7 @@ func (x *MintActorCertificateRequest) String() string { func (*MintActorCertificateRequest) ProtoMessage() {} func (x *MintActorCertificateRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[77] + mi := &file_ateapi_proto_msgTypes[78] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5826,7 +5919,7 @@ func (x *MintActorCertificateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MintActorCertificateRequest.ProtoReflect.Descriptor instead. func (*MintActorCertificateRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{77} + return file_ateapi_proto_rawDescGZIP(), []int{78} } func (x *MintActorCertificateRequest) GetActor() *ObjectRef { @@ -5863,7 +5956,7 @@ type MintActorCertificateResponse struct { func (x *MintActorCertificateResponse) Reset() { *x = MintActorCertificateResponse{} - mi := &file_ateapi_proto_msgTypes[78] + mi := &file_ateapi_proto_msgTypes[79] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5875,7 +5968,7 @@ func (x *MintActorCertificateResponse) String() string { func (*MintActorCertificateResponse) ProtoMessage() {} func (x *MintActorCertificateResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[78] + mi := &file_ateapi_proto_msgTypes[79] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5888,7 +5981,7 @@ func (x *MintActorCertificateResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MintActorCertificateResponse.ProtoReflect.Descriptor instead. func (*MintActorCertificateResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{78} + return file_ateapi_proto_rawDescGZIP(), []int{79} } func (x *MintActorCertificateResponse) GetActorCertificates() [][]byte { @@ -5915,7 +6008,7 @@ type ListTagsRequest struct { func (x *ListTagsRequest) Reset() { *x = ListTagsRequest{} - mi := &file_ateapi_proto_msgTypes[79] + mi := &file_ateapi_proto_msgTypes[80] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5927,7 +6020,7 @@ func (x *ListTagsRequest) String() string { func (*ListTagsRequest) ProtoMessage() {} func (x *ListTagsRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[79] + mi := &file_ateapi_proto_msgTypes[80] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5940,7 +6033,7 @@ func (x *ListTagsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListTagsRequest.ProtoReflect.Descriptor instead. func (*ListTagsRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{79} + return file_ateapi_proto_rawDescGZIP(), []int{80} } func (x *ListTagsRequest) GetAtespace() string { @@ -5967,7 +6060,7 @@ type ListTagsResponse struct { func (x *ListTagsResponse) Reset() { *x = ListTagsResponse{} - mi := &file_ateapi_proto_msgTypes[80] + mi := &file_ateapi_proto_msgTypes[81] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5979,7 +6072,7 @@ func (x *ListTagsResponse) String() string { func (*ListTagsResponse) ProtoMessage() {} func (x *ListTagsResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[80] + mi := &file_ateapi_proto_msgTypes[81] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5992,7 +6085,7 @@ func (x *ListTagsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListTagsResponse.ProtoReflect.Descriptor instead. func (*ListTagsResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{80} + return file_ateapi_proto_rawDescGZIP(), []int{81} } func (x *ListTagsResponse) GetTags() []*Tag { @@ -6037,7 +6130,7 @@ type CreateTagRequest struct { func (x *CreateTagRequest) Reset() { *x = CreateTagRequest{} - mi := &file_ateapi_proto_msgTypes[81] + mi := &file_ateapi_proto_msgTypes[82] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6049,7 +6142,7 @@ func (x *CreateTagRequest) String() string { func (*CreateTagRequest) ProtoMessage() {} func (x *CreateTagRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[81] + mi := &file_ateapi_proto_msgTypes[82] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6062,7 +6155,7 @@ func (x *CreateTagRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateTagRequest.ProtoReflect.Descriptor instead. func (*CreateTagRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{81} + return file_ateapi_proto_rawDescGZIP(), []int{82} } func (x *CreateTagRequest) GetTag() *Tag { @@ -6092,7 +6185,7 @@ type UpdateTagRequest struct { func (x *UpdateTagRequest) Reset() { *x = UpdateTagRequest{} - mi := &file_ateapi_proto_msgTypes[82] + mi := &file_ateapi_proto_msgTypes[83] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6104,7 +6197,7 @@ func (x *UpdateTagRequest) String() string { func (*UpdateTagRequest) ProtoMessage() {} func (x *UpdateTagRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[82] + mi := &file_ateapi_proto_msgTypes[83] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6117,7 +6210,7 @@ func (x *UpdateTagRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateTagRequest.ProtoReflect.Descriptor instead. func (*UpdateTagRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{82} + return file_ateapi_proto_rawDescGZIP(), []int{83} } func (x *UpdateTagRequest) GetTag() *Tag { @@ -6142,7 +6235,7 @@ type DeleteTagRequest struct { func (x *DeleteTagRequest) Reset() { *x = DeleteTagRequest{} - mi := &file_ateapi_proto_msgTypes[83] + mi := &file_ateapi_proto_msgTypes[84] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6154,7 +6247,7 @@ func (x *DeleteTagRequest) String() string { func (*DeleteTagRequest) ProtoMessage() {} func (x *DeleteTagRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[83] + mi := &file_ateapi_proto_msgTypes[84] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6167,7 +6260,7 @@ func (x *DeleteTagRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteTagRequest.ProtoReflect.Descriptor instead. func (*DeleteTagRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{83} + return file_ateapi_proto_rawDescGZIP(), []int{84} } func (x *DeleteTagRequest) GetTag() *ObjectRef { @@ -6206,7 +6299,7 @@ type DeleteOptions struct { func (x *DeleteOptions) Reset() { *x = DeleteOptions{} - mi := &file_ateapi_proto_msgTypes[84] + mi := &file_ateapi_proto_msgTypes[85] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6218,7 +6311,7 @@ func (x *DeleteOptions) String() string { func (*DeleteOptions) ProtoMessage() {} func (x *DeleteOptions) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[84] + mi := &file_ateapi_proto_msgTypes[85] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6231,7 +6324,7 @@ func (x *DeleteOptions) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteOptions.ProtoReflect.Descriptor instead. func (*DeleteOptions) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{84} + return file_ateapi_proto_rawDescGZIP(), []int{85} } func (x *DeleteOptions) GetVersion() int64 { @@ -6270,7 +6363,7 @@ type ListOptions struct { func (x *ListOptions) Reset() { *x = ListOptions{} - mi := &file_ateapi_proto_msgTypes[85] + mi := &file_ateapi_proto_msgTypes[86] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6282,7 +6375,7 @@ func (x *ListOptions) String() string { func (*ListOptions) ProtoMessage() {} func (x *ListOptions) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[85] + mi := &file_ateapi_proto_msgTypes[86] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6295,7 +6388,7 @@ func (x *ListOptions) ProtoReflect() protoreflect.Message { // Deprecated: Use ListOptions.ProtoReflect.Descriptor instead. func (*ListOptions) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{85} + return file_ateapi_proto_rawDescGZIP(), []int{86} } func (x *ListOptions) GetPageSize() int32 { @@ -6331,7 +6424,7 @@ type ListWorkerActorAssignmentsRequest struct { func (x *ListWorkerActorAssignmentsRequest) Reset() { *x = ListWorkerActorAssignmentsRequest{} - mi := &file_ateapi_proto_msgTypes[86] + mi := &file_ateapi_proto_msgTypes[87] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6343,7 +6436,7 @@ func (x *ListWorkerActorAssignmentsRequest) String() string { func (*ListWorkerActorAssignmentsRequest) ProtoMessage() {} func (x *ListWorkerActorAssignmentsRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[86] + mi := &file_ateapi_proto_msgTypes[87] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6356,7 +6449,7 @@ func (x *ListWorkerActorAssignmentsRequest) ProtoReflect() protoreflect.Message // Deprecated: Use ListWorkerActorAssignmentsRequest.ProtoReflect.Descriptor instead. func (*ListWorkerActorAssignmentsRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{86} + return file_ateapi_proto_rawDescGZIP(), []int{87} } func (x *ListWorkerActorAssignmentsRequest) GetWorker() *ObjectRef { @@ -6386,7 +6479,7 @@ type ListWorkerActorAssignmentsResponse struct { func (x *ListWorkerActorAssignmentsResponse) Reset() { *x = ListWorkerActorAssignmentsResponse{} - mi := &file_ateapi_proto_msgTypes[87] + mi := &file_ateapi_proto_msgTypes[88] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6398,7 +6491,7 @@ func (x *ListWorkerActorAssignmentsResponse) String() string { func (*ListWorkerActorAssignmentsResponse) ProtoMessage() {} func (x *ListWorkerActorAssignmentsResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[87] + mi := &file_ateapi_proto_msgTypes[88] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6411,7 +6504,7 @@ func (x *ListWorkerActorAssignmentsResponse) ProtoReflect() protoreflect.Message // Deprecated: Use ListWorkerActorAssignmentsResponse.ProtoReflect.Descriptor instead. func (*ListWorkerActorAssignmentsResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{87} + return file_ateapi_proto_rawDescGZIP(), []int{88} } func (x *ListWorkerActorAssignmentsResponse) GetActorAssignments() []*ActorAssignment { @@ -6440,7 +6533,7 @@ type ListWorkersRequest struct { func (x *ListWorkersRequest) Reset() { *x = ListWorkersRequest{} - mi := &file_ateapi_proto_msgTypes[88] + mi := &file_ateapi_proto_msgTypes[89] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6452,7 +6545,7 @@ func (x *ListWorkersRequest) String() string { func (*ListWorkersRequest) ProtoMessage() {} func (x *ListWorkersRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[88] + mi := &file_ateapi_proto_msgTypes[89] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6465,7 +6558,7 @@ func (x *ListWorkersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkersRequest.ProtoReflect.Descriptor instead. func (*ListWorkersRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{88} + return file_ateapi_proto_rawDescGZIP(), []int{89} } func (x *ListWorkersRequest) GetOptions() *ListOptions { @@ -6487,7 +6580,7 @@ type ListWorkersResponse struct { func (x *ListWorkersResponse) Reset() { *x = ListWorkersResponse{} - mi := &file_ateapi_proto_msgTypes[89] + mi := &file_ateapi_proto_msgTypes[90] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6499,7 +6592,7 @@ func (x *ListWorkersResponse) String() string { func (*ListWorkersResponse) ProtoMessage() {} func (x *ListWorkersResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[89] + mi := &file_ateapi_proto_msgTypes[90] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6512,7 +6605,7 @@ func (x *ListWorkersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkersResponse.ProtoReflect.Descriptor instead. func (*ListWorkersResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{89} + return file_ateapi_proto_rawDescGZIP(), []int{90} } func (x *ListWorkersResponse) GetWorkers() []*Worker { @@ -6542,7 +6635,7 @@ type GetWorkerRequest struct { func (x *GetWorkerRequest) Reset() { *x = GetWorkerRequest{} - mi := &file_ateapi_proto_msgTypes[90] + mi := &file_ateapi_proto_msgTypes[91] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6554,7 +6647,7 @@ func (x *GetWorkerRequest) String() string { func (*GetWorkerRequest) ProtoMessage() {} func (x *GetWorkerRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[90] + mi := &file_ateapi_proto_msgTypes[91] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6567,7 +6660,7 @@ func (x *GetWorkerRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetWorkerRequest.ProtoReflect.Descriptor instead. func (*GetWorkerRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{90} + return file_ateapi_proto_rawDescGZIP(), []int{91} } func (x *GetWorkerRequest) GetWorker() *ObjectRef { @@ -6589,7 +6682,7 @@ type CreateWorkerRequest struct { func (x *CreateWorkerRequest) Reset() { *x = CreateWorkerRequest{} - mi := &file_ateapi_proto_msgTypes[91] + mi := &file_ateapi_proto_msgTypes[92] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6601,7 +6694,7 @@ func (x *CreateWorkerRequest) String() string { func (*CreateWorkerRequest) ProtoMessage() {} func (x *CreateWorkerRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[91] + mi := &file_ateapi_proto_msgTypes[92] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6614,7 +6707,7 @@ func (x *CreateWorkerRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateWorkerRequest.ProtoReflect.Descriptor instead. func (*CreateWorkerRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{91} + return file_ateapi_proto_rawDescGZIP(), []int{92} } func (x *CreateWorkerRequest) GetWorker() *Worker { @@ -6649,7 +6742,7 @@ type UpdateWorkerRequest struct { func (x *UpdateWorkerRequest) Reset() { *x = UpdateWorkerRequest{} - mi := &file_ateapi_proto_msgTypes[92] + mi := &file_ateapi_proto_msgTypes[93] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6661,7 +6754,7 @@ func (x *UpdateWorkerRequest) String() string { func (*UpdateWorkerRequest) ProtoMessage() {} func (x *UpdateWorkerRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[92] + mi := &file_ateapi_proto_msgTypes[93] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6674,7 +6767,7 @@ func (x *UpdateWorkerRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateWorkerRequest.ProtoReflect.Descriptor instead. func (*UpdateWorkerRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{92} + return file_ateapi_proto_rawDescGZIP(), []int{93} } func (x *UpdateWorkerRequest) GetWorker() *Worker { @@ -6701,7 +6794,7 @@ type DeleteWorkerRequest struct { func (x *DeleteWorkerRequest) Reset() { *x = DeleteWorkerRequest{} - mi := &file_ateapi_proto_msgTypes[93] + mi := &file_ateapi_proto_msgTypes[94] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6713,7 +6806,7 @@ func (x *DeleteWorkerRequest) String() string { func (*DeleteWorkerRequest) ProtoMessage() {} func (x *DeleteWorkerRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[93] + mi := &file_ateapi_proto_msgTypes[94] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6726,7 +6819,7 @@ func (x *DeleteWorkerRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteWorkerRequest.ProtoReflect.Descriptor instead. func (*DeleteWorkerRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{93} + return file_ateapi_proto_rawDescGZIP(), []int{94} } func (x *DeleteWorkerRequest) GetWorker() *ObjectRef { @@ -6756,7 +6849,7 @@ type DrainWorkerRequest struct { func (x *DrainWorkerRequest) Reset() { *x = DrainWorkerRequest{} - mi := &file_ateapi_proto_msgTypes[94] + mi := &file_ateapi_proto_msgTypes[95] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6768,7 +6861,7 @@ func (x *DrainWorkerRequest) String() string { func (*DrainWorkerRequest) ProtoMessage() {} func (x *DrainWorkerRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[94] + mi := &file_ateapi_proto_msgTypes[95] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6781,7 +6874,7 @@ func (x *DrainWorkerRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DrainWorkerRequest.ProtoReflect.Descriptor instead. func (*DrainWorkerRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{94} + return file_ateapi_proto_rawDescGZIP(), []int{95} } func (x *DrainWorkerRequest) GetWorker() *ObjectRef { @@ -6802,7 +6895,7 @@ type DrainWorkerResponse struct { func (x *DrainWorkerResponse) Reset() { *x = DrainWorkerResponse{} - mi := &file_ateapi_proto_msgTypes[95] + mi := &file_ateapi_proto_msgTypes[96] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6814,7 +6907,7 @@ func (x *DrainWorkerResponse) String() string { func (*DrainWorkerResponse) ProtoMessage() {} func (x *DrainWorkerResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[95] + mi := &file_ateapi_proto_msgTypes[96] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6827,7 +6920,7 @@ func (x *DrainWorkerResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DrainWorkerResponse.ProtoReflect.Descriptor instead. func (*DrainWorkerResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{95} + return file_ateapi_proto_rawDescGZIP(), []int{96} } func (x *DrainWorkerResponse) GetWorker() *Worker { @@ -6851,7 +6944,7 @@ type MarkWorkerAvailableRequest struct { func (x *MarkWorkerAvailableRequest) Reset() { *x = MarkWorkerAvailableRequest{} - mi := &file_ateapi_proto_msgTypes[96] + mi := &file_ateapi_proto_msgTypes[97] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6863,7 +6956,7 @@ func (x *MarkWorkerAvailableRequest) String() string { func (*MarkWorkerAvailableRequest) ProtoMessage() {} func (x *MarkWorkerAvailableRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[96] + mi := &file_ateapi_proto_msgTypes[97] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6876,7 +6969,7 @@ func (x *MarkWorkerAvailableRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MarkWorkerAvailableRequest.ProtoReflect.Descriptor instead. func (*MarkWorkerAvailableRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{96} + return file_ateapi_proto_rawDescGZIP(), []int{97} } func (x *MarkWorkerAvailableRequest) GetWorker() *ObjectRef { @@ -6897,7 +6990,7 @@ type MarkWorkerAvailableResponse struct { func (x *MarkWorkerAvailableResponse) Reset() { *x = MarkWorkerAvailableResponse{} - mi := &file_ateapi_proto_msgTypes[97] + mi := &file_ateapi_proto_msgTypes[98] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6909,7 +7002,7 @@ func (x *MarkWorkerAvailableResponse) String() string { func (*MarkWorkerAvailableResponse) ProtoMessage() {} func (x *MarkWorkerAvailableResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[97] + mi := &file_ateapi_proto_msgTypes[98] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6922,7 +7015,7 @@ func (x *MarkWorkerAvailableResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MarkWorkerAvailableResponse.ProtoReflect.Descriptor instead. func (*MarkWorkerAvailableResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{97} + return file_ateapi_proto_rawDescGZIP(), []int{98} } func (x *MarkWorkerAvailableResponse) GetWorker() *Worker { @@ -6946,7 +7039,7 @@ type MarkWorkerUnavailableRequest struct { func (x *MarkWorkerUnavailableRequest) Reset() { *x = MarkWorkerUnavailableRequest{} - mi := &file_ateapi_proto_msgTypes[98] + mi := &file_ateapi_proto_msgTypes[99] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -6958,7 +7051,7 @@ func (x *MarkWorkerUnavailableRequest) String() string { func (*MarkWorkerUnavailableRequest) ProtoMessage() {} func (x *MarkWorkerUnavailableRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[98] + mi := &file_ateapi_proto_msgTypes[99] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -6971,7 +7064,7 @@ func (x *MarkWorkerUnavailableRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MarkWorkerUnavailableRequest.ProtoReflect.Descriptor instead. func (*MarkWorkerUnavailableRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{98} + return file_ateapi_proto_rawDescGZIP(), []int{99} } func (x *MarkWorkerUnavailableRequest) GetWorker() *ObjectRef { @@ -6992,7 +7085,7 @@ type MarkWorkerUnavailableResponse struct { func (x *MarkWorkerUnavailableResponse) Reset() { *x = MarkWorkerUnavailableResponse{} - mi := &file_ateapi_proto_msgTypes[99] + mi := &file_ateapi_proto_msgTypes[100] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7004,7 +7097,7 @@ func (x *MarkWorkerUnavailableResponse) String() string { func (*MarkWorkerUnavailableResponse) ProtoMessage() {} func (x *MarkWorkerUnavailableResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[99] + mi := &file_ateapi_proto_msgTypes[100] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7017,7 +7110,7 @@ func (x *MarkWorkerUnavailableResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MarkWorkerUnavailableResponse.ProtoReflect.Descriptor instead. func (*MarkWorkerUnavailableResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{99} + return file_ateapi_proto_rawDescGZIP(), []int{100} } func (x *MarkWorkerUnavailableResponse) GetWorker() *Worker { @@ -7046,7 +7139,7 @@ type ListActorsRequest struct { func (x *ListActorsRequest) Reset() { *x = ListActorsRequest{} - mi := &file_ateapi_proto_msgTypes[100] + mi := &file_ateapi_proto_msgTypes[101] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7058,7 +7151,7 @@ func (x *ListActorsRequest) String() string { func (*ListActorsRequest) ProtoMessage() {} func (x *ListActorsRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[100] + mi := &file_ateapi_proto_msgTypes[101] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7071,7 +7164,7 @@ func (x *ListActorsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListActorsRequest.ProtoReflect.Descriptor instead. func (*ListActorsRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{100} + return file_ateapi_proto_rawDescGZIP(), []int{101} } func (x *ListActorsRequest) GetAtespace() string { @@ -7100,7 +7193,7 @@ type ListActorsResponse struct { func (x *ListActorsResponse) Reset() { *x = ListActorsResponse{} - mi := &file_ateapi_proto_msgTypes[101] + mi := &file_ateapi_proto_msgTypes[102] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7112,7 +7205,7 @@ func (x *ListActorsResponse) String() string { func (*ListActorsResponse) ProtoMessage() {} func (x *ListActorsResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[101] + mi := &file_ateapi_proto_msgTypes[102] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7125,7 +7218,7 @@ func (x *ListActorsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListActorsResponse.ProtoReflect.Descriptor instead. func (*ListActorsResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{101} + return file_ateapi_proto_rawDescGZIP(), []int{102} } func (x *ListActorsResponse) GetActors() []*Actor { @@ -7234,7 +7327,7 @@ type Worker struct { func (x *Worker) Reset() { *x = Worker{} - mi := &file_ateapi_proto_msgTypes[102] + mi := &file_ateapi_proto_msgTypes[103] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7246,7 +7339,7 @@ func (x *Worker) String() string { func (*Worker) ProtoMessage() {} func (x *Worker) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[102] + mi := &file_ateapi_proto_msgTypes[103] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7259,7 +7352,7 @@ func (x *Worker) ProtoReflect() protoreflect.Message { // Deprecated: Use Worker.ProtoReflect.Descriptor instead. func (*Worker) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{102} + return file_ateapi_proto_rawDescGZIP(), []int{103} } func (x *Worker) GetMetadata() *ResourceMetadata { @@ -7388,7 +7481,7 @@ type WorkerStatus struct { func (x *WorkerStatus) Reset() { *x = WorkerStatus{} - mi := &file_ateapi_proto_msgTypes[103] + mi := &file_ateapi_proto_msgTypes[104] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7400,7 +7493,7 @@ func (x *WorkerStatus) String() string { func (*WorkerStatus) ProtoMessage() {} func (x *WorkerStatus) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[103] + mi := &file_ateapi_proto_msgTypes[104] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7413,7 +7506,7 @@ func (x *WorkerStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use WorkerStatus.ProtoReflect.Descriptor instead. func (*WorkerStatus) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{103} + return file_ateapi_proto_rawDescGZIP(), []int{104} } func (x *WorkerStatus) GetState() WorkerState { @@ -7481,7 +7574,7 @@ type SandboxRuntime struct { func (x *SandboxRuntime) Reset() { *x = SandboxRuntime{} - mi := &file_ateapi_proto_msgTypes[104] + mi := &file_ateapi_proto_msgTypes[105] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7493,7 +7586,7 @@ func (x *SandboxRuntime) String() string { func (*SandboxRuntime) ProtoMessage() {} func (x *SandboxRuntime) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[104] + mi := &file_ateapi_proto_msgTypes[105] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7506,7 +7599,7 @@ func (x *SandboxRuntime) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxRuntime.ProtoReflect.Descriptor instead. func (*SandboxRuntime) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{104} + return file_ateapi_proto_rawDescGZIP(), []int{105} } func (x *SandboxRuntime) GetSandboxClass() string { @@ -7556,7 +7649,7 @@ type VersionedSandboxCompat struct { func (x *VersionedSandboxCompat) Reset() { *x = VersionedSandboxCompat{} - mi := &file_ateapi_proto_msgTypes[105] + mi := &file_ateapi_proto_msgTypes[106] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7568,7 +7661,7 @@ func (x *VersionedSandboxCompat) String() string { func (*VersionedSandboxCompat) ProtoMessage() {} func (x *VersionedSandboxCompat) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[105] + mi := &file_ateapi_proto_msgTypes[106] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7581,7 +7674,7 @@ func (x *VersionedSandboxCompat) ProtoReflect() protoreflect.Message { // Deprecated: Use VersionedSandboxCompat.ProtoReflect.Descriptor instead. func (*VersionedSandboxCompat) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{105} + return file_ateapi_proto_rawDescGZIP(), []int{106} } func (x *VersionedSandboxCompat) GetSchemaVersion() string { @@ -7617,7 +7710,7 @@ type AttributeEntry struct { func (x *AttributeEntry) Reset() { *x = AttributeEntry{} - mi := &file_ateapi_proto_msgTypes[106] + mi := &file_ateapi_proto_msgTypes[107] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7629,7 +7722,7 @@ func (x *AttributeEntry) String() string { func (*AttributeEntry) ProtoMessage() {} func (x *AttributeEntry) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[106] + mi := &file_ateapi_proto_msgTypes[107] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7642,7 +7735,7 @@ func (x *AttributeEntry) ProtoReflect() protoreflect.Message { // Deprecated: Use AttributeEntry.ProtoReflect.Descriptor instead. func (*AttributeEntry) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{106} + return file_ateapi_proto_rawDescGZIP(), []int{107} } func (x *AttributeEntry) GetKey() string { @@ -7681,7 +7774,7 @@ type WorkerResources struct { func (x *WorkerResources) Reset() { *x = WorkerResources{} - mi := &file_ateapi_proto_msgTypes[107] + mi := &file_ateapi_proto_msgTypes[108] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7693,7 +7786,7 @@ func (x *WorkerResources) String() string { func (*WorkerResources) ProtoMessage() {} func (x *WorkerResources) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[107] + mi := &file_ateapi_proto_msgTypes[108] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7706,7 +7799,7 @@ func (x *WorkerResources) ProtoReflect() protoreflect.Message { // Deprecated: Use WorkerResources.ProtoReflect.Descriptor instead. func (*WorkerResources) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{107} + return file_ateapi_proto_rawDescGZIP(), []int{108} } func (x *WorkerResources) GetResources() *Resources { @@ -7759,7 +7852,7 @@ type ActorAssignment struct { func (x *ActorAssignment) Reset() { *x = ActorAssignment{} - mi := &file_ateapi_proto_msgTypes[108] + mi := &file_ateapi_proto_msgTypes[109] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7771,7 +7864,7 @@ func (x *ActorAssignment) String() string { func (*ActorAssignment) ProtoMessage() {} func (x *ActorAssignment) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[108] + mi := &file_ateapi_proto_msgTypes[109] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7784,7 +7877,7 @@ func (x *ActorAssignment) ProtoReflect() protoreflect.Message { // Deprecated: Use ActorAssignment.ProtoReflect.Descriptor instead. func (*ActorAssignment) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{108} + return file_ateapi_proto_rawDescGZIP(), []int{109} } func (x *ActorAssignment) GetMetadata() *ResourceMetadata { @@ -7855,7 +7948,7 @@ type RegisterWorkerRequest struct { func (x *RegisterWorkerRequest) Reset() { *x = RegisterWorkerRequest{} - mi := &file_ateapi_proto_msgTypes[109] + mi := &file_ateapi_proto_msgTypes[110] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7867,7 +7960,7 @@ func (x *RegisterWorkerRequest) String() string { func (*RegisterWorkerRequest) ProtoMessage() {} func (x *RegisterWorkerRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[109] + mi := &file_ateapi_proto_msgTypes[110] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7880,7 +7973,7 @@ func (x *RegisterWorkerRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RegisterWorkerRequest.ProtoReflect.Descriptor instead. func (*RegisterWorkerRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{109} + return file_ateapi_proto_rawDescGZIP(), []int{110} } func (x *RegisterWorkerRequest) GetWorker() *ObjectRef { @@ -7921,7 +8014,7 @@ type RegisterWorkerResponse struct { func (x *RegisterWorkerResponse) Reset() { *x = RegisterWorkerResponse{} - mi := &file_ateapi_proto_msgTypes[110] + mi := &file_ateapi_proto_msgTypes[111] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7933,7 +8026,7 @@ func (x *RegisterWorkerResponse) String() string { func (*RegisterWorkerResponse) ProtoMessage() {} func (x *RegisterWorkerResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[110] + mi := &file_ateapi_proto_msgTypes[111] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -7946,7 +8039,7 @@ func (x *RegisterWorkerResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RegisterWorkerResponse.ProtoReflect.Descriptor instead. func (*RegisterWorkerResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{110} + return file_ateapi_proto_rawDescGZIP(), []int{111} } func (x *RegisterWorkerResponse) GetWorker() *Worker { @@ -7985,7 +8078,7 @@ type MintWorkerActorCertificateRequest struct { func (x *MintWorkerActorCertificateRequest) Reset() { *x = MintWorkerActorCertificateRequest{} - mi := &file_ateapi_proto_msgTypes[111] + mi := &file_ateapi_proto_msgTypes[112] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -7997,7 +8090,7 @@ func (x *MintWorkerActorCertificateRequest) String() string { func (*MintWorkerActorCertificateRequest) ProtoMessage() {} func (x *MintWorkerActorCertificateRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[111] + mi := &file_ateapi_proto_msgTypes[112] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8010,7 +8103,7 @@ func (x *MintWorkerActorCertificateRequest) ProtoReflect() protoreflect.Message // Deprecated: Use MintWorkerActorCertificateRequest.ProtoReflect.Descriptor instead. func (*MintWorkerActorCertificateRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{111} + return file_ateapi_proto_rawDescGZIP(), []int{112} } func (x *MintWorkerActorCertificateRequest) GetActor() *ObjectRef { @@ -8047,7 +8140,7 @@ type MintWorkerActorCertificateResponse struct { func (x *MintWorkerActorCertificateResponse) Reset() { *x = MintWorkerActorCertificateResponse{} - mi := &file_ateapi_proto_msgTypes[112] + mi := &file_ateapi_proto_msgTypes[113] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8059,7 +8152,7 @@ func (x *MintWorkerActorCertificateResponse) String() string { func (*MintWorkerActorCertificateResponse) ProtoMessage() {} func (x *MintWorkerActorCertificateResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[112] + mi := &file_ateapi_proto_msgTypes[113] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8072,7 +8165,7 @@ func (x *MintWorkerActorCertificateResponse) ProtoReflect() protoreflect.Message // Deprecated: Use MintWorkerActorCertificateResponse.ProtoReflect.Descriptor instead. func (*MintWorkerActorCertificateResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{112} + return file_ateapi_proto_rawDescGZIP(), []int{113} } func (x *MintWorkerActorCertificateResponse) GetActorCertificates() [][]byte { @@ -8113,7 +8206,7 @@ type MintWorkerActorJwtRequest struct { func (x *MintWorkerActorJwtRequest) Reset() { *x = MintWorkerActorJwtRequest{} - mi := &file_ateapi_proto_msgTypes[113] + mi := &file_ateapi_proto_msgTypes[114] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8125,7 +8218,7 @@ func (x *MintWorkerActorJwtRequest) String() string { func (*MintWorkerActorJwtRequest) ProtoMessage() {} func (x *MintWorkerActorJwtRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[113] + mi := &file_ateapi_proto_msgTypes[114] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8138,7 +8231,7 @@ func (x *MintWorkerActorJwtRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MintWorkerActorJwtRequest.ProtoReflect.Descriptor instead. func (*MintWorkerActorJwtRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{113} + return file_ateapi_proto_rawDescGZIP(), []int{114} } func (x *MintWorkerActorJwtRequest) GetActor() *ObjectRef { @@ -8184,7 +8277,7 @@ type MintWorkerActorJwtResponse struct { func (x *MintWorkerActorJwtResponse) Reset() { *x = MintWorkerActorJwtResponse{} - mi := &file_ateapi_proto_msgTypes[114] + mi := &file_ateapi_proto_msgTypes[115] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8196,7 +8289,7 @@ func (x *MintWorkerActorJwtResponse) String() string { func (*MintWorkerActorJwtResponse) ProtoMessage() {} func (x *MintWorkerActorJwtResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[114] + mi := &file_ateapi_proto_msgTypes[115] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8209,7 +8302,7 @@ func (x *MintWorkerActorJwtResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MintWorkerActorJwtResponse.ProtoReflect.Descriptor instead. func (*MintWorkerActorJwtResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{114} + return file_ateapi_proto_rawDescGZIP(), []int{115} } func (x *MintWorkerActorJwtResponse) GetActorJwt() string { @@ -8254,7 +8347,7 @@ type RequestActorSuspendRequest struct { func (x *RequestActorSuspendRequest) Reset() { *x = RequestActorSuspendRequest{} - mi := &file_ateapi_proto_msgTypes[115] + mi := &file_ateapi_proto_msgTypes[116] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8266,7 +8359,7 @@ func (x *RequestActorSuspendRequest) String() string { func (*RequestActorSuspendRequest) ProtoMessage() {} func (x *RequestActorSuspendRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[115] + mi := &file_ateapi_proto_msgTypes[116] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8279,7 +8372,7 @@ func (x *RequestActorSuspendRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use RequestActorSuspendRequest.ProtoReflect.Descriptor instead. func (*RequestActorSuspendRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{115} + return file_ateapi_proto_rawDescGZIP(), []int{116} } func (x *RequestActorSuspendRequest) GetWorker() *ObjectRef { @@ -8313,7 +8406,7 @@ type RequestActorSuspendResponse struct { func (x *RequestActorSuspendResponse) Reset() { *x = RequestActorSuspendResponse{} - mi := &file_ateapi_proto_msgTypes[116] + mi := &file_ateapi_proto_msgTypes[117] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8325,7 +8418,7 @@ func (x *RequestActorSuspendResponse) String() string { func (*RequestActorSuspendResponse) ProtoMessage() {} func (x *RequestActorSuspendResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[116] + mi := &file_ateapi_proto_msgTypes[117] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8338,7 +8431,7 @@ func (x *RequestActorSuspendResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use RequestActorSuspendResponse.ProtoReflect.Descriptor instead. func (*RequestActorSuspendResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{116} + return file_ateapi_proto_rawDescGZIP(), []int{117} } func (x *RequestActorSuspendResponse) GetActor() *Actor { @@ -8369,7 +8462,7 @@ type ReportActorSnapshotStateRequest struct { func (x *ReportActorSnapshotStateRequest) Reset() { *x = ReportActorSnapshotStateRequest{} - mi := &file_ateapi_proto_msgTypes[117] + mi := &file_ateapi_proto_msgTypes[118] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8381,7 +8474,7 @@ func (x *ReportActorSnapshotStateRequest) String() string { func (*ReportActorSnapshotStateRequest) ProtoMessage() {} func (x *ReportActorSnapshotStateRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[117] + mi := &file_ateapi_proto_msgTypes[118] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8394,7 +8487,7 @@ func (x *ReportActorSnapshotStateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportActorSnapshotStateRequest.ProtoReflect.Descriptor instead. func (*ReportActorSnapshotStateRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{117} + return file_ateapi_proto_rawDescGZIP(), []int{118} } func (x *ReportActorSnapshotStateRequest) GetActor() *ObjectRef { @@ -8426,7 +8519,7 @@ type ReportActorSnapshotStateResponse struct { func (x *ReportActorSnapshotStateResponse) Reset() { *x = ReportActorSnapshotStateResponse{} - mi := &file_ateapi_proto_msgTypes[118] + mi := &file_ateapi_proto_msgTypes[119] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8438,7 +8531,7 @@ func (x *ReportActorSnapshotStateResponse) String() string { func (*ReportActorSnapshotStateResponse) ProtoMessage() {} func (x *ReportActorSnapshotStateResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[118] + mi := &file_ateapi_proto_msgTypes[119] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8451,7 +8544,7 @@ func (x *ReportActorSnapshotStateResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ReportActorSnapshotStateResponse.ProtoReflect.Descriptor instead. func (*ReportActorSnapshotStateResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{118} + return file_ateapi_proto_rawDescGZIP(), []int{119} } // ActorSnapshotState is what atelet holds for one Actor on its node. It @@ -8485,7 +8578,7 @@ type ActorSnapshotState struct { func (x *ActorSnapshotState) Reset() { *x = ActorSnapshotState{} - mi := &file_ateapi_proto_msgTypes[119] + mi := &file_ateapi_proto_msgTypes[120] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8497,7 +8590,7 @@ func (x *ActorSnapshotState) String() string { func (*ActorSnapshotState) ProtoMessage() {} func (x *ActorSnapshotState) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[119] + mi := &file_ateapi_proto_msgTypes[120] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8510,7 +8603,7 @@ func (x *ActorSnapshotState) ProtoReflect() protoreflect.Message { // Deprecated: Use ActorSnapshotState.ProtoReflect.Descriptor instead. func (*ActorSnapshotState) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{119} + return file_ateapi_proto_rawDescGZIP(), []int{120} } func (x *ActorSnapshotState) GetLatestLocal() *SnapshotReport { @@ -8582,7 +8675,7 @@ type SnapshotReport struct { func (x *SnapshotReport) Reset() { *x = SnapshotReport{} - mi := &file_ateapi_proto_msgTypes[120] + mi := &file_ateapi_proto_msgTypes[121] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8594,7 +8687,7 @@ func (x *SnapshotReport) String() string { func (*SnapshotReport) ProtoMessage() {} func (x *SnapshotReport) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[120] + mi := &file_ateapi_proto_msgTypes[121] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8607,7 +8700,7 @@ func (x *SnapshotReport) ProtoReflect() protoreflect.Message { // Deprecated: Use SnapshotReport.ProtoReflect.Descriptor instead. func (*SnapshotReport) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{120} + return file_ateapi_proto_rawDescGZIP(), []int{121} } func (x *SnapshotReport) GetUuid() string { @@ -8677,7 +8770,7 @@ type AccessPolicy struct { func (x *AccessPolicy) Reset() { *x = AccessPolicy{} - mi := &file_ateapi_proto_msgTypes[121] + mi := &file_ateapi_proto_msgTypes[122] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8689,7 +8782,7 @@ func (x *AccessPolicy) String() string { func (*AccessPolicy) ProtoMessage() {} func (x *AccessPolicy) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[121] + mi := &file_ateapi_proto_msgTypes[122] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8702,7 +8795,7 @@ func (x *AccessPolicy) ProtoReflect() protoreflect.Message { // Deprecated: Use AccessPolicy.ProtoReflect.Descriptor instead. func (*AccessPolicy) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{121} + return file_ateapi_proto_rawDescGZIP(), []int{122} } func (x *AccessPolicy) GetMetadata() *ResourceMetadata { @@ -8744,7 +8837,7 @@ type Binding struct { func (x *Binding) Reset() { *x = Binding{} - mi := &file_ateapi_proto_msgTypes[122] + mi := &file_ateapi_proto_msgTypes[123] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8756,7 +8849,7 @@ func (x *Binding) String() string { func (*Binding) ProtoMessage() {} func (x *Binding) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[122] + mi := &file_ateapi_proto_msgTypes[123] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8769,7 +8862,7 @@ func (x *Binding) ProtoReflect() protoreflect.Message { // Deprecated: Use Binding.ProtoReflect.Descriptor instead. func (*Binding) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{122} + return file_ateapi_proto_rawDescGZIP(), []int{123} } func (x *Binding) GetRole() string { @@ -8801,7 +8894,7 @@ type GetGlobalAccessPolicyRequest struct { func (x *GetGlobalAccessPolicyRequest) Reset() { *x = GetGlobalAccessPolicyRequest{} - mi := &file_ateapi_proto_msgTypes[123] + mi := &file_ateapi_proto_msgTypes[124] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8813,7 +8906,7 @@ func (x *GetGlobalAccessPolicyRequest) String() string { func (*GetGlobalAccessPolicyRequest) ProtoMessage() {} func (x *GetGlobalAccessPolicyRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[123] + mi := &file_ateapi_proto_msgTypes[124] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8826,7 +8919,7 @@ func (x *GetGlobalAccessPolicyRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetGlobalAccessPolicyRequest.ProtoReflect.Descriptor instead. func (*GetGlobalAccessPolicyRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{123} + return file_ateapi_proto_rawDescGZIP(), []int{124} } func (x *GetGlobalAccessPolicyRequest) GetName() string { @@ -8850,7 +8943,7 @@ type CreateGlobalAccessPolicyRequest struct { func (x *CreateGlobalAccessPolicyRequest) Reset() { *x = CreateGlobalAccessPolicyRequest{} - mi := &file_ateapi_proto_msgTypes[124] + mi := &file_ateapi_proto_msgTypes[125] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8862,7 +8955,7 @@ func (x *CreateGlobalAccessPolicyRequest) String() string { func (*CreateGlobalAccessPolicyRequest) ProtoMessage() {} func (x *CreateGlobalAccessPolicyRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[124] + mi := &file_ateapi_proto_msgTypes[125] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8875,7 +8968,7 @@ func (x *CreateGlobalAccessPolicyRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateGlobalAccessPolicyRequest.ProtoReflect.Descriptor instead. func (*CreateGlobalAccessPolicyRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{124} + return file_ateapi_proto_rawDescGZIP(), []int{125} } func (x *CreateGlobalAccessPolicyRequest) GetAccessPolicy() *AccessPolicy { @@ -8899,7 +8992,7 @@ type UpdateGlobalAccessPolicyRequest struct { func (x *UpdateGlobalAccessPolicyRequest) Reset() { *x = UpdateGlobalAccessPolicyRequest{} - mi := &file_ateapi_proto_msgTypes[125] + mi := &file_ateapi_proto_msgTypes[126] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8911,7 +9004,7 @@ func (x *UpdateGlobalAccessPolicyRequest) String() string { func (*UpdateGlobalAccessPolicyRequest) ProtoMessage() {} func (x *UpdateGlobalAccessPolicyRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[125] + mi := &file_ateapi_proto_msgTypes[126] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8924,7 +9017,7 @@ func (x *UpdateGlobalAccessPolicyRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateGlobalAccessPolicyRequest.ProtoReflect.Descriptor instead. func (*UpdateGlobalAccessPolicyRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{125} + return file_ateapi_proto_rawDescGZIP(), []int{126} } func (x *UpdateGlobalAccessPolicyRequest) GetAccessPolicy() *AccessPolicy { @@ -8954,7 +9047,7 @@ type GetAtespaceAccessPolicyRequest struct { func (x *GetAtespaceAccessPolicyRequest) Reset() { *x = GetAtespaceAccessPolicyRequest{} - mi := &file_ateapi_proto_msgTypes[126] + mi := &file_ateapi_proto_msgTypes[127] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -8966,7 +9059,7 @@ func (x *GetAtespaceAccessPolicyRequest) String() string { func (*GetAtespaceAccessPolicyRequest) ProtoMessage() {} func (x *GetAtespaceAccessPolicyRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[126] + mi := &file_ateapi_proto_msgTypes[127] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -8979,7 +9072,7 @@ func (x *GetAtespaceAccessPolicyRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetAtespaceAccessPolicyRequest.ProtoReflect.Descriptor instead. func (*GetAtespaceAccessPolicyRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{126} + return file_ateapi_proto_rawDescGZIP(), []int{127} } func (x *GetAtespaceAccessPolicyRequest) GetAtespace() *ObjectRef { @@ -9015,7 +9108,7 @@ type CreateAtespaceAccessPolicyRequest struct { func (x *CreateAtespaceAccessPolicyRequest) Reset() { *x = CreateAtespaceAccessPolicyRequest{} - mi := &file_ateapi_proto_msgTypes[127] + mi := &file_ateapi_proto_msgTypes[128] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9027,7 +9120,7 @@ func (x *CreateAtespaceAccessPolicyRequest) String() string { func (*CreateAtespaceAccessPolicyRequest) ProtoMessage() {} func (x *CreateAtespaceAccessPolicyRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[127] + mi := &file_ateapi_proto_msgTypes[128] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9040,7 +9133,7 @@ func (x *CreateAtespaceAccessPolicyRequest) ProtoReflect() protoreflect.Message // Deprecated: Use CreateAtespaceAccessPolicyRequest.ProtoReflect.Descriptor instead. func (*CreateAtespaceAccessPolicyRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{127} + return file_ateapi_proto_rawDescGZIP(), []int{128} } func (x *CreateAtespaceAccessPolicyRequest) GetAtespace() *ObjectRef { @@ -9076,7 +9169,7 @@ type UpdateAtespaceAccessPolicyRequest struct { func (x *UpdateAtespaceAccessPolicyRequest) Reset() { *x = UpdateAtespaceAccessPolicyRequest{} - mi := &file_ateapi_proto_msgTypes[128] + mi := &file_ateapi_proto_msgTypes[129] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9088,7 +9181,7 @@ func (x *UpdateAtespaceAccessPolicyRequest) String() string { func (*UpdateAtespaceAccessPolicyRequest) ProtoMessage() {} func (x *UpdateAtespaceAccessPolicyRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[128] + mi := &file_ateapi_proto_msgTypes[129] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9101,7 +9194,7 @@ func (x *UpdateAtespaceAccessPolicyRequest) ProtoReflect() protoreflect.Message // Deprecated: Use UpdateAtespaceAccessPolicyRequest.ProtoReflect.Descriptor instead. func (*UpdateAtespaceAccessPolicyRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{128} + return file_ateapi_proto_rawDescGZIP(), []int{129} } func (x *UpdateAtespaceAccessPolicyRequest) GetAtespace() *ObjectRef { @@ -9142,7 +9235,7 @@ type DeleteAtespaceAccessPolicyRequest struct { func (x *DeleteAtespaceAccessPolicyRequest) Reset() { *x = DeleteAtespaceAccessPolicyRequest{} - mi := &file_ateapi_proto_msgTypes[129] + mi := &file_ateapi_proto_msgTypes[130] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9154,7 +9247,7 @@ func (x *DeleteAtespaceAccessPolicyRequest) String() string { func (*DeleteAtespaceAccessPolicyRequest) ProtoMessage() {} func (x *DeleteAtespaceAccessPolicyRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[129] + mi := &file_ateapi_proto_msgTypes[130] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9167,7 +9260,7 @@ func (x *DeleteAtespaceAccessPolicyRequest) ProtoReflect() protoreflect.Message // Deprecated: Use DeleteAtespaceAccessPolicyRequest.ProtoReflect.Descriptor instead. func (*DeleteAtespaceAccessPolicyRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{129} + return file_ateapi_proto_rawDescGZIP(), []int{130} } func (x *DeleteAtespaceAccessPolicyRequest) GetAtespace() *ObjectRef { @@ -9213,7 +9306,7 @@ type ResourceAnnotation struct { func (x *ResourceAnnotation) Reset() { *x = ResourceAnnotation{} - mi := &file_ateapi_proto_msgTypes[130] + mi := &file_ateapi_proto_msgTypes[131] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9225,7 +9318,7 @@ func (x *ResourceAnnotation) String() string { func (*ResourceAnnotation) ProtoMessage() {} func (x *ResourceAnnotation) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[130] + mi := &file_ateapi_proto_msgTypes[131] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9238,7 +9331,7 @@ func (x *ResourceAnnotation) ProtoReflect() protoreflect.Message { // Deprecated: Use ResourceAnnotation.ProtoReflect.Descriptor instead. func (*ResourceAnnotation) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{130} + return file_ateapi_proto_rawDescGZIP(), []int{131} } func (x *ResourceAnnotation) GetParents() []string { @@ -9281,7 +9374,7 @@ type MethodAnnotation struct { func (x *MethodAnnotation) Reset() { *x = MethodAnnotation{} - mi := &file_ateapi_proto_msgTypes[131] + mi := &file_ateapi_proto_msgTypes[132] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -9293,7 +9386,7 @@ func (x *MethodAnnotation) String() string { func (*MethodAnnotation) ProtoMessage() {} func (x *MethodAnnotation) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[131] + mi := &file_ateapi_proto_msgTypes[132] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -9306,7 +9399,7 @@ func (x *MethodAnnotation) ProtoReflect() protoreflect.Message { // Deprecated: Use MethodAnnotation.ProtoReflect.Descriptor instead. func (*MethodAnnotation) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{131} + return file_ateapi_proto_rawDescGZIP(), []int{132} } func (x *MethodAnnotation) GetResource() string { @@ -9402,7 +9495,9 @@ const file_ateapi_proto_rawDesc = "" + "\fEgressPolicy\x124\n" + "\bmetadata\x18\x01 \x01(\v2\x18.ateapi.ResourceMetadataR\bmetadata\x12(\n" + "\x05rules\x18\x02 \x03(\v2\x12.ateapi.EgressRuleR\x05rules:\x1d\x82\xb5\x18\x19\n" + - "\x05Actor\x10\x01\"\x0eEgressPolicies\"\xa0\x01\n" + + "\x05Actor\x10\x01\"\x0eEgressPolicies\"@\n" + + "\x14EgressPolicyTemplate\x12(\n" + + "\x05rules\x18\x01 \x03(\v2\x12.ateapi.EgressRuleR\x05rules\"\xa0\x01\n" + "\n" + "EgressRule\x12$\n" + "\x04http\x18\x01 \x01(\v2\x10.ateapi.HttpRuleR\x04http\x12'\n" + @@ -9472,7 +9567,7 @@ const file_ateapi_proto_rawDesc = "" + "\bmetadata\x18\x01 \x01(\v2\x18.ateapi.ResourceMetadataR\bmetadata:\x11\x82\xb5\x18\r\x18\x02\"\tAtespaces\";\n" + "\tObjectRef\x12\x1a\n" + "\batespace\x18\x01 \x01(\tR\batespace\x12\x12\n" + - "\x04name\x18\x02 \x01(\tR\x04name\"\xda\x03\n" + + "\x04name\x18\x02 \x01(\tR\x04name\"\xaa\x04\n" + "\rActorTemplate\x124\n" + "\bmetadata\x18\x01 \x01(\v2\x18.ateapi.ResourceMetadataR\bmetadata\x129\n" + "\x0fworker_selector\x18\x02 \x01(\v2\x10.ateapi.SelectorR\x0eworkerSelector\x121\n" + @@ -9483,7 +9578,8 @@ const file_ateapi_proto_rawDesc = "" + "\x0fsnapshot_config\x18\x05 \x01(\v2\x16.ateapi.SnapshotConfigR\x0esnapshotConfig\x12<\n" + "\x0esandbox_config\x18\x06 \x01(\v2\x15.ateapi.SandboxConfigR\rsandboxConfig\x12/\n" + "\tresources\x18\a \x01(\v2\x11.ateapi.ResourcesR\tresources\x123\n" + - "\x06status\x18\b \x01(\v2\x1b.ateapi.ActorTemplateStatusR\x06status:\x16\x82\xb5\x18\x12\x18\x01\"\x0eActorTemplates\"3\n" + + "\x06status\x18\b \x01(\v2\x1b.ateapi.ActorTemplateStatusR\x06status\x12N\n" + + "\x14golden_egress_policy\x18\t \x01(\v2\x1c.ateapi.EgressPolicyTemplateR\x12goldenEgressPolicy:\x16\x82\xb5\x18\x12\x18\x01\"\x0eActorTemplates\"3\n" + "\tResources\x12&\n" + "\x06limits\x18\x01 \x03(\v2\x0e.ateapi.LimitsR\x06limits\"8\n" + "\x06Limits\x12\x12\n" + @@ -9587,9 +9683,10 @@ const file_ateapi_proto_rawDesc = "" + "\x0eactor_template\x18\x01 \x01(\v2\x11.ateapi.ObjectRefR\ractorTemplate\x12/\n" + "\aoptions\x18\x02 \x01(\v2\x15.ateapi.DeleteOptionsR\aoptions\":\n" + "\x0fGetActorRequest\x12'\n" + - "\x05actor\x18\x01 \x01(\v2\x11.ateapi.ObjectRefR\x05actor\"9\n" + + "\x05actor\x18\x01 \x01(\v2\x11.ateapi.ObjectRefR\x05actor\"\x83\x01\n" + "\x12CreateActorRequest\x12#\n" + - "\x05actor\x18\x01 \x01(\v2\r.ateapi.ActorR\x05actor\"9\n" + + "\x05actor\x18\x01 \x01(\v2\r.ateapi.ActorR\x05actor\x12H\n" + + "\x15initial_egress_policy\x18\x02 \x01(\v2\x14.ateapi.EgressPolicyR\x13initialEgressPolicy\"9\n" + "\x12UpdateActorRequest\x12#\n" + "\x05actor\x18\x01 \x01(\v2\r.ateapi.ActorR\x05actor\">\n" + "\x13SuspendActorRequest\x12'\n" + @@ -9987,7 +10084,7 @@ func file_ateapi_proto_rawDescGZIP() []byte { } var file_ateapi_proto_enumTypes = make([]protoimpl.EnumInfo, 9) -var file_ateapi_proto_msgTypes = make([]protoimpl.MessageInfo, 135) +var file_ateapi_proto_msgTypes = make([]protoimpl.MessageInfo, 136) var file_ateapi_proto_goTypes = []any{ (SnapshotOwner)(0), // 0: ateapi.SnapshotOwner (SnapshotStorageStatus)(0), // 1: ateapi.SnapshotStorageStatus @@ -10006,136 +10103,137 @@ var file_ateapi_proto_goTypes = []any{ (*ExternalVolume)(nil), // 14: ateapi.ExternalVolume (*Actor)(nil), // 15: ateapi.Actor (*EgressPolicy)(nil), // 16: ateapi.EgressPolicy - (*EgressRule)(nil), // 17: ateapi.EgressRule - (*HttpRule)(nil), // 18: ateapi.HttpRule - (*HttpsRule)(nil), // 19: ateapi.HttpsRule - (*TlsPassthroughRule)(nil), // 20: ateapi.TlsPassthroughRule - (*Ports)(nil), // 21: ateapi.Ports - (*AllPorts)(nil), // 22: ateapi.AllPorts - (*HttpRuleEffects)(nil), // 23: ateapi.HttpRuleEffects - (*CredentialHeader)(nil), // 24: ateapi.CredentialHeader - (*ActorJwtSource)(nil), // 25: ateapi.ActorJwtSource - (*ActorStatus)(nil), // 26: ateapi.ActorStatus - (*ActorCrash)(nil), // 27: ateapi.ActorCrash - (*WorkerAssignment)(nil), // 28: ateapi.WorkerAssignment - (*TagStatus)(nil), // 29: ateapi.TagStatus - (*Tag)(nil), // 30: ateapi.Tag - (*Atespace)(nil), // 31: ateapi.Atespace - (*ObjectRef)(nil), // 32: ateapi.ObjectRef - (*ActorTemplate)(nil), // 33: ateapi.ActorTemplate - (*Resources)(nil), // 34: ateapi.Resources - (*Limits)(nil), // 35: ateapi.Limits - (*GoldenSnapshotStatus)(nil), // 36: ateapi.GoldenSnapshotStatus - (*ActorTemplateStatus)(nil), // 37: ateapi.ActorTemplateStatus - (*SandboxConfig)(nil), // 38: ateapi.SandboxConfig - (*SnapshotConfig)(nil), // 39: ateapi.SnapshotConfig - (*GoldenSnapshotConfig)(nil), // 40: ateapi.GoldenSnapshotConfig - (*Container)(nil), // 41: ateapi.Container - (*SecurityContext)(nil), // 42: ateapi.SecurityContext - (*Capabilities)(nil), // 43: ateapi.Capabilities - (*EnvVar)(nil), // 44: ateapi.EnvVar - (*WakeupProbe)(nil), // 45: ateapi.WakeupProbe - (*HttpGetAction)(nil), // 46: ateapi.HttpGetAction - (*Volume)(nil), // 47: ateapi.Volume - (*ImageVolumeSource)(nil), // 48: ateapi.ImageVolumeSource - (*DurableDirVolumeSource)(nil), // 49: ateapi.DurableDirVolumeSource - (*ExternalVolumeTemplate)(nil), // 50: ateapi.ExternalVolumeTemplate - (*SystemInfoVolumeSource)(nil), // 51: ateapi.SystemInfoVolumeSource - (*SystemInfoDataSource)(nil), // 52: ateapi.SystemInfoDataSource - (*ActorMetadataDataSource)(nil), // 53: ateapi.ActorMetadataDataSource - (*ActorMetadataItem)(nil), // 54: ateapi.ActorMetadataItem - (*TrustBundleDataSource)(nil), // 55: ateapi.TrustBundleDataSource - (*VolumeMount)(nil), // 56: ateapi.VolumeMount - (*CreateAtespaceRequest)(nil), // 57: ateapi.CreateAtespaceRequest - (*GetAtespaceRequest)(nil), // 58: ateapi.GetAtespaceRequest - (*ListAtespacesRequest)(nil), // 59: ateapi.ListAtespacesRequest - (*ListAtespacesResponse)(nil), // 60: ateapi.ListAtespacesResponse - (*DeleteAtespaceRequest)(nil), // 61: ateapi.DeleteAtespaceRequest - (*CreateActorTemplateRequest)(nil), // 62: ateapi.CreateActorTemplateRequest - (*GetActorTemplateRequest)(nil), // 63: ateapi.GetActorTemplateRequest - (*ListActorTemplatesRequest)(nil), // 64: ateapi.ListActorTemplatesRequest - (*ListActorTemplatesResponse)(nil), // 65: ateapi.ListActorTemplatesResponse - (*DeleteActorTemplateRequest)(nil), // 66: ateapi.DeleteActorTemplateRequest - (*GetActorRequest)(nil), // 67: ateapi.GetActorRequest - (*CreateActorRequest)(nil), // 68: ateapi.CreateActorRequest - (*UpdateActorRequest)(nil), // 69: ateapi.UpdateActorRequest - (*SuspendActorRequest)(nil), // 70: ateapi.SuspendActorRequest - (*SuspendActorResponse)(nil), // 71: ateapi.SuspendActorResponse - (*PauseActorRequest)(nil), // 72: ateapi.PauseActorRequest - (*PauseActorResponse)(nil), // 73: ateapi.PauseActorResponse - (*ResumeActorRequest)(nil), // 74: ateapi.ResumeActorRequest - (*ResumeActorResponse)(nil), // 75: ateapi.ResumeActorResponse - (*RevertActorRequest)(nil), // 76: ateapi.RevertActorRequest - (*RevertActorResponse)(nil), // 77: ateapi.RevertActorResponse - (*DeleteActorRequest)(nil), // 78: ateapi.DeleteActorRequest - (*GetActorEgressPolicyRequest)(nil), // 79: ateapi.GetActorEgressPolicyRequest - (*CreateActorEgressPolicyRequest)(nil), // 80: ateapi.CreateActorEgressPolicyRequest - (*UpdateActorEgressPolicyRequest)(nil), // 81: ateapi.UpdateActorEgressPolicyRequest - (*DeleteActorEgressPolicyRequest)(nil), // 82: ateapi.DeleteActorEgressPolicyRequest - (*GetTagRequest)(nil), // 83: ateapi.GetTagRequest - (*MintActorJwtRequest)(nil), // 84: ateapi.MintActorJwtRequest - (*MintActorJwtResponse)(nil), // 85: ateapi.MintActorJwtResponse - (*MintActorCertificateRequest)(nil), // 86: ateapi.MintActorCertificateRequest - (*MintActorCertificateResponse)(nil), // 87: ateapi.MintActorCertificateResponse - (*ListTagsRequest)(nil), // 88: ateapi.ListTagsRequest - (*ListTagsResponse)(nil), // 89: ateapi.ListTagsResponse - (*CreateTagRequest)(nil), // 90: ateapi.CreateTagRequest - (*UpdateTagRequest)(nil), // 91: ateapi.UpdateTagRequest - (*DeleteTagRequest)(nil), // 92: ateapi.DeleteTagRequest - (*DeleteOptions)(nil), // 93: ateapi.DeleteOptions - (*ListOptions)(nil), // 94: ateapi.ListOptions - (*ListWorkerActorAssignmentsRequest)(nil), // 95: ateapi.ListWorkerActorAssignmentsRequest - (*ListWorkerActorAssignmentsResponse)(nil), // 96: ateapi.ListWorkerActorAssignmentsResponse - (*ListWorkersRequest)(nil), // 97: ateapi.ListWorkersRequest - (*ListWorkersResponse)(nil), // 98: ateapi.ListWorkersResponse - (*GetWorkerRequest)(nil), // 99: ateapi.GetWorkerRequest - (*CreateWorkerRequest)(nil), // 100: ateapi.CreateWorkerRequest - (*UpdateWorkerRequest)(nil), // 101: ateapi.UpdateWorkerRequest - (*DeleteWorkerRequest)(nil), // 102: ateapi.DeleteWorkerRequest - (*DrainWorkerRequest)(nil), // 103: ateapi.DrainWorkerRequest - (*DrainWorkerResponse)(nil), // 104: ateapi.DrainWorkerResponse - (*MarkWorkerAvailableRequest)(nil), // 105: ateapi.MarkWorkerAvailableRequest - (*MarkWorkerAvailableResponse)(nil), // 106: ateapi.MarkWorkerAvailableResponse - (*MarkWorkerUnavailableRequest)(nil), // 107: ateapi.MarkWorkerUnavailableRequest - (*MarkWorkerUnavailableResponse)(nil), // 108: ateapi.MarkWorkerUnavailableResponse - (*ListActorsRequest)(nil), // 109: ateapi.ListActorsRequest - (*ListActorsResponse)(nil), // 110: ateapi.ListActorsResponse - (*Worker)(nil), // 111: ateapi.Worker - (*WorkerStatus)(nil), // 112: ateapi.WorkerStatus - (*SandboxRuntime)(nil), // 113: ateapi.SandboxRuntime - (*VersionedSandboxCompat)(nil), // 114: ateapi.VersionedSandboxCompat - (*AttributeEntry)(nil), // 115: ateapi.AttributeEntry - (*WorkerResources)(nil), // 116: ateapi.WorkerResources - (*ActorAssignment)(nil), // 117: ateapi.ActorAssignment - (*RegisterWorkerRequest)(nil), // 118: ateapi.RegisterWorkerRequest - (*RegisterWorkerResponse)(nil), // 119: ateapi.RegisterWorkerResponse - (*MintWorkerActorCertificateRequest)(nil), // 120: ateapi.MintWorkerActorCertificateRequest - (*MintWorkerActorCertificateResponse)(nil), // 121: ateapi.MintWorkerActorCertificateResponse - (*MintWorkerActorJwtRequest)(nil), // 122: ateapi.MintWorkerActorJwtRequest - (*MintWorkerActorJwtResponse)(nil), // 123: ateapi.MintWorkerActorJwtResponse - (*RequestActorSuspendRequest)(nil), // 124: ateapi.RequestActorSuspendRequest - (*RequestActorSuspendResponse)(nil), // 125: ateapi.RequestActorSuspendResponse - (*ReportActorSnapshotStateRequest)(nil), // 126: ateapi.ReportActorSnapshotStateRequest - (*ReportActorSnapshotStateResponse)(nil), // 127: ateapi.ReportActorSnapshotStateResponse - (*ActorSnapshotState)(nil), // 128: ateapi.ActorSnapshotState - (*SnapshotReport)(nil), // 129: ateapi.SnapshotReport - (*AccessPolicy)(nil), // 130: ateapi.AccessPolicy - (*Binding)(nil), // 131: ateapi.Binding - (*GetGlobalAccessPolicyRequest)(nil), // 132: ateapi.GetGlobalAccessPolicyRequest - (*CreateGlobalAccessPolicyRequest)(nil), // 133: ateapi.CreateGlobalAccessPolicyRequest - (*UpdateGlobalAccessPolicyRequest)(nil), // 134: ateapi.UpdateGlobalAccessPolicyRequest - (*GetAtespaceAccessPolicyRequest)(nil), // 135: ateapi.GetAtespaceAccessPolicyRequest - (*CreateAtespaceAccessPolicyRequest)(nil), // 136: ateapi.CreateAtespaceAccessPolicyRequest - (*UpdateAtespaceAccessPolicyRequest)(nil), // 137: ateapi.UpdateAtespaceAccessPolicyRequest - (*DeleteAtespaceAccessPolicyRequest)(nil), // 138: ateapi.DeleteAtespaceAccessPolicyRequest - (*ResourceAnnotation)(nil), // 139: ateapi.ResourceAnnotation - (*MethodAnnotation)(nil), // 140: ateapi.MethodAnnotation - nil, // 141: ateapi.Selector.MatchLabelsEntry - nil, // 142: ateapi.ExternalVolume.VolumeContextEntry - nil, // 143: ateapi.Worker.LabelsEntry - (*timestamppb.Timestamp)(nil), // 144: google.protobuf.Timestamp - (*descriptorpb.MessageOptions)(nil), // 145: google.protobuf.MessageOptions - (*descriptorpb.MethodOptions)(nil), // 146: google.protobuf.MethodOptions + (*EgressPolicyTemplate)(nil), // 17: ateapi.EgressPolicyTemplate + (*EgressRule)(nil), // 18: ateapi.EgressRule + (*HttpRule)(nil), // 19: ateapi.HttpRule + (*HttpsRule)(nil), // 20: ateapi.HttpsRule + (*TlsPassthroughRule)(nil), // 21: ateapi.TlsPassthroughRule + (*Ports)(nil), // 22: ateapi.Ports + (*AllPorts)(nil), // 23: ateapi.AllPorts + (*HttpRuleEffects)(nil), // 24: ateapi.HttpRuleEffects + (*CredentialHeader)(nil), // 25: ateapi.CredentialHeader + (*ActorJwtSource)(nil), // 26: ateapi.ActorJwtSource + (*ActorStatus)(nil), // 27: ateapi.ActorStatus + (*ActorCrash)(nil), // 28: ateapi.ActorCrash + (*WorkerAssignment)(nil), // 29: ateapi.WorkerAssignment + (*TagStatus)(nil), // 30: ateapi.TagStatus + (*Tag)(nil), // 31: ateapi.Tag + (*Atespace)(nil), // 32: ateapi.Atespace + (*ObjectRef)(nil), // 33: ateapi.ObjectRef + (*ActorTemplate)(nil), // 34: ateapi.ActorTemplate + (*Resources)(nil), // 35: ateapi.Resources + (*Limits)(nil), // 36: ateapi.Limits + (*GoldenSnapshotStatus)(nil), // 37: ateapi.GoldenSnapshotStatus + (*ActorTemplateStatus)(nil), // 38: ateapi.ActorTemplateStatus + (*SandboxConfig)(nil), // 39: ateapi.SandboxConfig + (*SnapshotConfig)(nil), // 40: ateapi.SnapshotConfig + (*GoldenSnapshotConfig)(nil), // 41: ateapi.GoldenSnapshotConfig + (*Container)(nil), // 42: ateapi.Container + (*SecurityContext)(nil), // 43: ateapi.SecurityContext + (*Capabilities)(nil), // 44: ateapi.Capabilities + (*EnvVar)(nil), // 45: ateapi.EnvVar + (*WakeupProbe)(nil), // 46: ateapi.WakeupProbe + (*HttpGetAction)(nil), // 47: ateapi.HttpGetAction + (*Volume)(nil), // 48: ateapi.Volume + (*ImageVolumeSource)(nil), // 49: ateapi.ImageVolumeSource + (*DurableDirVolumeSource)(nil), // 50: ateapi.DurableDirVolumeSource + (*ExternalVolumeTemplate)(nil), // 51: ateapi.ExternalVolumeTemplate + (*SystemInfoVolumeSource)(nil), // 52: ateapi.SystemInfoVolumeSource + (*SystemInfoDataSource)(nil), // 53: ateapi.SystemInfoDataSource + (*ActorMetadataDataSource)(nil), // 54: ateapi.ActorMetadataDataSource + (*ActorMetadataItem)(nil), // 55: ateapi.ActorMetadataItem + (*TrustBundleDataSource)(nil), // 56: ateapi.TrustBundleDataSource + (*VolumeMount)(nil), // 57: ateapi.VolumeMount + (*CreateAtespaceRequest)(nil), // 58: ateapi.CreateAtespaceRequest + (*GetAtespaceRequest)(nil), // 59: ateapi.GetAtespaceRequest + (*ListAtespacesRequest)(nil), // 60: ateapi.ListAtespacesRequest + (*ListAtespacesResponse)(nil), // 61: ateapi.ListAtespacesResponse + (*DeleteAtespaceRequest)(nil), // 62: ateapi.DeleteAtespaceRequest + (*CreateActorTemplateRequest)(nil), // 63: ateapi.CreateActorTemplateRequest + (*GetActorTemplateRequest)(nil), // 64: ateapi.GetActorTemplateRequest + (*ListActorTemplatesRequest)(nil), // 65: ateapi.ListActorTemplatesRequest + (*ListActorTemplatesResponse)(nil), // 66: ateapi.ListActorTemplatesResponse + (*DeleteActorTemplateRequest)(nil), // 67: ateapi.DeleteActorTemplateRequest + (*GetActorRequest)(nil), // 68: ateapi.GetActorRequest + (*CreateActorRequest)(nil), // 69: ateapi.CreateActorRequest + (*UpdateActorRequest)(nil), // 70: ateapi.UpdateActorRequest + (*SuspendActorRequest)(nil), // 71: ateapi.SuspendActorRequest + (*SuspendActorResponse)(nil), // 72: ateapi.SuspendActorResponse + (*PauseActorRequest)(nil), // 73: ateapi.PauseActorRequest + (*PauseActorResponse)(nil), // 74: ateapi.PauseActorResponse + (*ResumeActorRequest)(nil), // 75: ateapi.ResumeActorRequest + (*ResumeActorResponse)(nil), // 76: ateapi.ResumeActorResponse + (*RevertActorRequest)(nil), // 77: ateapi.RevertActorRequest + (*RevertActorResponse)(nil), // 78: ateapi.RevertActorResponse + (*DeleteActorRequest)(nil), // 79: ateapi.DeleteActorRequest + (*GetActorEgressPolicyRequest)(nil), // 80: ateapi.GetActorEgressPolicyRequest + (*CreateActorEgressPolicyRequest)(nil), // 81: ateapi.CreateActorEgressPolicyRequest + (*UpdateActorEgressPolicyRequest)(nil), // 82: ateapi.UpdateActorEgressPolicyRequest + (*DeleteActorEgressPolicyRequest)(nil), // 83: ateapi.DeleteActorEgressPolicyRequest + (*GetTagRequest)(nil), // 84: ateapi.GetTagRequest + (*MintActorJwtRequest)(nil), // 85: ateapi.MintActorJwtRequest + (*MintActorJwtResponse)(nil), // 86: ateapi.MintActorJwtResponse + (*MintActorCertificateRequest)(nil), // 87: ateapi.MintActorCertificateRequest + (*MintActorCertificateResponse)(nil), // 88: ateapi.MintActorCertificateResponse + (*ListTagsRequest)(nil), // 89: ateapi.ListTagsRequest + (*ListTagsResponse)(nil), // 90: ateapi.ListTagsResponse + (*CreateTagRequest)(nil), // 91: ateapi.CreateTagRequest + (*UpdateTagRequest)(nil), // 92: ateapi.UpdateTagRequest + (*DeleteTagRequest)(nil), // 93: ateapi.DeleteTagRequest + (*DeleteOptions)(nil), // 94: ateapi.DeleteOptions + (*ListOptions)(nil), // 95: ateapi.ListOptions + (*ListWorkerActorAssignmentsRequest)(nil), // 96: ateapi.ListWorkerActorAssignmentsRequest + (*ListWorkerActorAssignmentsResponse)(nil), // 97: ateapi.ListWorkerActorAssignmentsResponse + (*ListWorkersRequest)(nil), // 98: ateapi.ListWorkersRequest + (*ListWorkersResponse)(nil), // 99: ateapi.ListWorkersResponse + (*GetWorkerRequest)(nil), // 100: ateapi.GetWorkerRequest + (*CreateWorkerRequest)(nil), // 101: ateapi.CreateWorkerRequest + (*UpdateWorkerRequest)(nil), // 102: ateapi.UpdateWorkerRequest + (*DeleteWorkerRequest)(nil), // 103: ateapi.DeleteWorkerRequest + (*DrainWorkerRequest)(nil), // 104: ateapi.DrainWorkerRequest + (*DrainWorkerResponse)(nil), // 105: ateapi.DrainWorkerResponse + (*MarkWorkerAvailableRequest)(nil), // 106: ateapi.MarkWorkerAvailableRequest + (*MarkWorkerAvailableResponse)(nil), // 107: ateapi.MarkWorkerAvailableResponse + (*MarkWorkerUnavailableRequest)(nil), // 108: ateapi.MarkWorkerUnavailableRequest + (*MarkWorkerUnavailableResponse)(nil), // 109: ateapi.MarkWorkerUnavailableResponse + (*ListActorsRequest)(nil), // 110: ateapi.ListActorsRequest + (*ListActorsResponse)(nil), // 111: ateapi.ListActorsResponse + (*Worker)(nil), // 112: ateapi.Worker + (*WorkerStatus)(nil), // 113: ateapi.WorkerStatus + (*SandboxRuntime)(nil), // 114: ateapi.SandboxRuntime + (*VersionedSandboxCompat)(nil), // 115: ateapi.VersionedSandboxCompat + (*AttributeEntry)(nil), // 116: ateapi.AttributeEntry + (*WorkerResources)(nil), // 117: ateapi.WorkerResources + (*ActorAssignment)(nil), // 118: ateapi.ActorAssignment + (*RegisterWorkerRequest)(nil), // 119: ateapi.RegisterWorkerRequest + (*RegisterWorkerResponse)(nil), // 120: ateapi.RegisterWorkerResponse + (*MintWorkerActorCertificateRequest)(nil), // 121: ateapi.MintWorkerActorCertificateRequest + (*MintWorkerActorCertificateResponse)(nil), // 122: ateapi.MintWorkerActorCertificateResponse + (*MintWorkerActorJwtRequest)(nil), // 123: ateapi.MintWorkerActorJwtRequest + (*MintWorkerActorJwtResponse)(nil), // 124: ateapi.MintWorkerActorJwtResponse + (*RequestActorSuspendRequest)(nil), // 125: ateapi.RequestActorSuspendRequest + (*RequestActorSuspendResponse)(nil), // 126: ateapi.RequestActorSuspendResponse + (*ReportActorSnapshotStateRequest)(nil), // 127: ateapi.ReportActorSnapshotStateRequest + (*ReportActorSnapshotStateResponse)(nil), // 128: ateapi.ReportActorSnapshotStateResponse + (*ActorSnapshotState)(nil), // 129: ateapi.ActorSnapshotState + (*SnapshotReport)(nil), // 130: ateapi.SnapshotReport + (*AccessPolicy)(nil), // 131: ateapi.AccessPolicy + (*Binding)(nil), // 132: ateapi.Binding + (*GetGlobalAccessPolicyRequest)(nil), // 133: ateapi.GetGlobalAccessPolicyRequest + (*CreateGlobalAccessPolicyRequest)(nil), // 134: ateapi.CreateGlobalAccessPolicyRequest + (*UpdateGlobalAccessPolicyRequest)(nil), // 135: ateapi.UpdateGlobalAccessPolicyRequest + (*GetAtespaceAccessPolicyRequest)(nil), // 136: ateapi.GetAtespaceAccessPolicyRequest + (*CreateAtespaceAccessPolicyRequest)(nil), // 137: ateapi.CreateAtespaceAccessPolicyRequest + (*UpdateAtespaceAccessPolicyRequest)(nil), // 138: ateapi.UpdateAtespaceAccessPolicyRequest + (*DeleteAtespaceAccessPolicyRequest)(nil), // 139: ateapi.DeleteAtespaceAccessPolicyRequest + (*ResourceAnnotation)(nil), // 140: ateapi.ResourceAnnotation + (*MethodAnnotation)(nil), // 141: ateapi.MethodAnnotation + nil, // 142: ateapi.Selector.MatchLabelsEntry + nil, // 143: ateapi.ExternalVolume.VolumeContextEntry + nil, // 144: ateapi.Worker.LabelsEntry + (*timestamppb.Timestamp)(nil), // 145: google.protobuf.Timestamp + (*descriptorpb.MessageOptions)(nil), // 146: google.protobuf.MessageOptions + (*descriptorpb.MethodOptions)(nil), // 147: google.protobuf.MethodOptions } var file_ateapi_proto_depIdxs = []int32{ 1, // 0: ateapi.SnapshotStorage.status:type_name -> ateapi.SnapshotStorageStatus @@ -10143,288 +10241,291 @@ var file_ateapi_proto_depIdxs = []int32{ 0, // 2: ateapi.Snapshot.owner:type_name -> ateapi.SnapshotOwner 2, // 3: ateapi.Snapshot.fidelity:type_name -> ateapi.SnapshotFidelity 10, // 4: ateapi.Snapshot.durable_snapshot:type_name -> ateapi.SnapshotStorage - 113, // 5: ateapi.Snapshot.sandbox_runtime:type_name -> ateapi.SandboxRuntime - 141, // 6: ateapi.Selector.match_labels:type_name -> ateapi.Selector.MatchLabelsEntry - 144, // 7: ateapi.ResourceMetadata.create_time:type_name -> google.protobuf.Timestamp - 144, // 8: ateapi.ResourceMetadata.update_time:type_name -> google.protobuf.Timestamp - 142, // 9: ateapi.ExternalVolume.volume_context:type_name -> ateapi.ExternalVolume.VolumeContextEntry + 114, // 5: ateapi.Snapshot.sandbox_runtime:type_name -> ateapi.SandboxRuntime + 142, // 6: ateapi.Selector.match_labels:type_name -> ateapi.Selector.MatchLabelsEntry + 145, // 7: ateapi.ResourceMetadata.create_time:type_name -> google.protobuf.Timestamp + 145, // 8: ateapi.ResourceMetadata.update_time:type_name -> google.protobuf.Timestamp + 143, // 9: ateapi.ExternalVolume.volume_context:type_name -> ateapi.ExternalVolume.VolumeContextEntry 13, // 10: ateapi.Actor.metadata:type_name -> ateapi.ResourceMetadata - 32, // 11: ateapi.Actor.actor_template:type_name -> ateapi.ObjectRef + 33, // 11: ateapi.Actor.actor_template:type_name -> ateapi.ObjectRef 12, // 12: ateapi.Actor.worker_selector:type_name -> ateapi.Selector - 32, // 13: ateapi.Actor.source_tag:type_name -> ateapi.ObjectRef - 26, // 14: ateapi.Actor.status:type_name -> ateapi.ActorStatus + 33, // 13: ateapi.Actor.source_tag:type_name -> ateapi.ObjectRef + 27, // 14: ateapi.Actor.status:type_name -> ateapi.ActorStatus 13, // 15: ateapi.EgressPolicy.metadata:type_name -> ateapi.ResourceMetadata - 17, // 16: ateapi.EgressPolicy.rules:type_name -> ateapi.EgressRule - 18, // 17: ateapi.EgressRule.http:type_name -> ateapi.HttpRule - 19, // 18: ateapi.EgressRule.https:type_name -> ateapi.HttpsRule - 20, // 19: ateapi.EgressRule.tls_passthrough:type_name -> ateapi.TlsPassthroughRule - 21, // 20: ateapi.HttpRule.ports:type_name -> ateapi.Ports - 23, // 21: ateapi.HttpRule.effects:type_name -> ateapi.HttpRuleEffects - 21, // 22: ateapi.HttpsRule.ports:type_name -> ateapi.Ports - 23, // 23: ateapi.HttpsRule.effects:type_name -> ateapi.HttpRuleEffects - 21, // 24: ateapi.TlsPassthroughRule.ports:type_name -> ateapi.Ports - 22, // 25: ateapi.Ports.all:type_name -> ateapi.AllPorts - 24, // 26: ateapi.HttpRuleEffects.replace_headers:type_name -> ateapi.CredentialHeader - 25, // 27: ateapi.CredentialHeader.actor_jwt:type_name -> ateapi.ActorJwtSource - 4, // 28: ateapi.ActorStatus.state:type_name -> ateapi.ActorState - 28, // 29: ateapi.ActorStatus.worker_assignment:type_name -> ateapi.WorkerAssignment - 14, // 30: ateapi.ActorStatus.external_volumes:type_name -> ateapi.ExternalVolume - 27, // 31: ateapi.ActorStatus.crash:type_name -> ateapi.ActorCrash - 11, // 32: ateapi.ActorStatus.snapshots:type_name -> ateapi.Snapshot - 144, // 33: ateapi.ActorCrash.crash_time:type_name -> google.protobuf.Timestamp - 32, // 34: ateapi.WorkerAssignment.worker:type_name -> ateapi.ObjectRef - 113, // 35: ateapi.WorkerAssignment.sandbox_runtime:type_name -> ateapi.SandboxRuntime - 11, // 36: ateapi.TagStatus.snapshot:type_name -> ateapi.Snapshot - 13, // 37: ateapi.Tag.metadata:type_name -> ateapi.ResourceMetadata - 29, // 38: ateapi.Tag.status:type_name -> ateapi.TagStatus - 3, // 39: ateapi.Tag.scope:type_name -> ateapi.TagScope - 32, // 40: ateapi.Tag.source_actor:type_name -> ateapi.ObjectRef - 13, // 41: ateapi.Atespace.metadata:type_name -> ateapi.ResourceMetadata - 13, // 42: ateapi.ActorTemplate.metadata:type_name -> ateapi.ResourceMetadata - 12, // 43: ateapi.ActorTemplate.worker_selector:type_name -> ateapi.Selector - 41, // 44: ateapi.ActorTemplate.containers:type_name -> ateapi.Container - 47, // 45: ateapi.ActorTemplate.volumes:type_name -> ateapi.Volume - 39, // 46: ateapi.ActorTemplate.snapshot_config:type_name -> ateapi.SnapshotConfig - 38, // 47: ateapi.ActorTemplate.sandbox_config:type_name -> ateapi.SandboxConfig - 34, // 48: ateapi.ActorTemplate.resources:type_name -> ateapi.Resources - 37, // 49: ateapi.ActorTemplate.status:type_name -> ateapi.ActorTemplateStatus - 35, // 50: ateapi.Resources.limits:type_name -> ateapi.Limits - 32, // 51: ateapi.GoldenSnapshotStatus.golden_tag:type_name -> ateapi.ObjectRef - 144, // 52: ateapi.GoldenSnapshotStatus.snapshot_time:type_name -> google.protobuf.Timestamp - 36, // 53: ateapi.ActorTemplateStatus.golden_snapshot_status:type_name -> ateapi.GoldenSnapshotStatus - 2, // 54: ateapi.SnapshotConfig.preferred_fidelity:type_name -> ateapi.SnapshotFidelity - 40, // 55: ateapi.SnapshotConfig.golden_snapshot_config:type_name -> ateapi.GoldenSnapshotConfig - 5, // 56: ateapi.GoldenSnapshotConfig.mode:type_name -> ateapi.GoldenSnapshotMode - 44, // 57: ateapi.Container.env:type_name -> ateapi.EnvVar - 45, // 58: ateapi.Container.wakeup_probe:type_name -> ateapi.WakeupProbe - 56, // 59: ateapi.Container.volume_mounts:type_name -> ateapi.VolumeMount - 42, // 60: ateapi.Container.security_context:type_name -> ateapi.SecurityContext - 34, // 61: ateapi.Container.resources:type_name -> ateapi.Resources - 43, // 62: ateapi.SecurityContext.capabilities:type_name -> ateapi.Capabilities - 46, // 63: ateapi.WakeupProbe.http_get:type_name -> ateapi.HttpGetAction - 49, // 64: ateapi.Volume.durable_dir:type_name -> ateapi.DurableDirVolumeSource - 50, // 65: ateapi.Volume.external_volume_template:type_name -> ateapi.ExternalVolumeTemplate - 51, // 66: ateapi.Volume.system_info:type_name -> ateapi.SystemInfoVolumeSource - 48, // 67: ateapi.Volume.image:type_name -> ateapi.ImageVolumeSource - 52, // 68: ateapi.SystemInfoVolumeSource.data_sources:type_name -> ateapi.SystemInfoDataSource - 53, // 69: ateapi.SystemInfoDataSource.actor_metadata:type_name -> ateapi.ActorMetadataDataSource - 55, // 70: ateapi.SystemInfoDataSource.trust_bundle:type_name -> ateapi.TrustBundleDataSource - 54, // 71: ateapi.ActorMetadataDataSource.items:type_name -> ateapi.ActorMetadataItem - 6, // 72: ateapi.ActorMetadataItem.field:type_name -> ateapi.ActorMetadataField - 31, // 73: ateapi.CreateAtespaceRequest.atespace:type_name -> ateapi.Atespace - 32, // 74: ateapi.GetAtespaceRequest.atespace:type_name -> ateapi.ObjectRef - 94, // 75: ateapi.ListAtespacesRequest.options:type_name -> ateapi.ListOptions - 31, // 76: ateapi.ListAtespacesResponse.atespaces:type_name -> ateapi.Atespace - 32, // 77: ateapi.DeleteAtespaceRequest.atespace:type_name -> ateapi.ObjectRef - 93, // 78: ateapi.DeleteAtespaceRequest.options:type_name -> ateapi.DeleteOptions - 33, // 79: ateapi.CreateActorTemplateRequest.actor_template:type_name -> ateapi.ActorTemplate - 32, // 80: ateapi.GetActorTemplateRequest.actor_template:type_name -> ateapi.ObjectRef - 94, // 81: ateapi.ListActorTemplatesRequest.options:type_name -> ateapi.ListOptions - 33, // 82: ateapi.ListActorTemplatesResponse.actor_templates:type_name -> ateapi.ActorTemplate - 32, // 83: ateapi.DeleteActorTemplateRequest.actor_template:type_name -> ateapi.ObjectRef - 93, // 84: ateapi.DeleteActorTemplateRequest.options:type_name -> ateapi.DeleteOptions - 32, // 85: ateapi.GetActorRequest.actor:type_name -> ateapi.ObjectRef - 15, // 86: ateapi.CreateActorRequest.actor:type_name -> ateapi.Actor - 15, // 87: ateapi.UpdateActorRequest.actor:type_name -> ateapi.Actor - 32, // 88: ateapi.SuspendActorRequest.actor:type_name -> ateapi.ObjectRef - 15, // 89: ateapi.SuspendActorResponse.actor:type_name -> ateapi.Actor - 32, // 90: ateapi.PauseActorRequest.actor:type_name -> ateapi.ObjectRef - 15, // 91: ateapi.PauseActorResponse.actor:type_name -> ateapi.Actor - 32, // 92: ateapi.ResumeActorRequest.actor:type_name -> ateapi.ObjectRef - 15, // 93: ateapi.ResumeActorResponse.actor:type_name -> ateapi.Actor - 32, // 94: ateapi.RevertActorRequest.actor:type_name -> ateapi.ObjectRef - 15, // 95: ateapi.RevertActorResponse.actor:type_name -> ateapi.Actor - 32, // 96: ateapi.DeleteActorRequest.actor:type_name -> ateapi.ObjectRef - 93, // 97: ateapi.DeleteActorRequest.options:type_name -> ateapi.DeleteOptions - 32, // 98: ateapi.GetActorEgressPolicyRequest.actor:type_name -> ateapi.ObjectRef - 32, // 99: ateapi.CreateActorEgressPolicyRequest.actor:type_name -> ateapi.ObjectRef - 16, // 100: ateapi.CreateActorEgressPolicyRequest.egress_policy:type_name -> ateapi.EgressPolicy - 32, // 101: ateapi.UpdateActorEgressPolicyRequest.actor:type_name -> ateapi.ObjectRef - 16, // 102: ateapi.UpdateActorEgressPolicyRequest.egress_policy:type_name -> ateapi.EgressPolicy - 32, // 103: ateapi.DeleteActorEgressPolicyRequest.actor:type_name -> ateapi.ObjectRef - 93, // 104: ateapi.DeleteActorEgressPolicyRequest.options:type_name -> ateapi.DeleteOptions - 32, // 105: ateapi.GetTagRequest.tag:type_name -> ateapi.ObjectRef - 32, // 106: ateapi.MintActorJwtRequest.actor:type_name -> ateapi.ObjectRef - 144, // 107: ateapi.MintActorJwtResponse.expire_time:type_name -> google.protobuf.Timestamp - 32, // 108: ateapi.MintActorCertificateRequest.actor:type_name -> ateapi.ObjectRef - 94, // 109: ateapi.ListTagsRequest.options:type_name -> ateapi.ListOptions - 30, // 110: ateapi.ListTagsResponse.tags:type_name -> ateapi.Tag - 30, // 111: ateapi.CreateTagRequest.tag:type_name -> ateapi.Tag - 30, // 112: ateapi.UpdateTagRequest.tag:type_name -> ateapi.Tag - 32, // 113: ateapi.DeleteTagRequest.tag:type_name -> ateapi.ObjectRef - 93, // 114: ateapi.DeleteTagRequest.options:type_name -> ateapi.DeleteOptions - 32, // 115: ateapi.ListWorkerActorAssignmentsRequest.worker:type_name -> ateapi.ObjectRef - 94, // 116: ateapi.ListWorkerActorAssignmentsRequest.options:type_name -> ateapi.ListOptions - 117, // 117: ateapi.ListWorkerActorAssignmentsResponse.actor_assignments:type_name -> ateapi.ActorAssignment - 94, // 118: ateapi.ListWorkersRequest.options:type_name -> ateapi.ListOptions - 111, // 119: ateapi.ListWorkersResponse.workers:type_name -> ateapi.Worker - 32, // 120: ateapi.GetWorkerRequest.worker:type_name -> ateapi.ObjectRef - 111, // 121: ateapi.CreateWorkerRequest.worker:type_name -> ateapi.Worker - 111, // 122: ateapi.UpdateWorkerRequest.worker:type_name -> ateapi.Worker - 32, // 123: ateapi.DeleteWorkerRequest.worker:type_name -> ateapi.ObjectRef - 93, // 124: ateapi.DeleteWorkerRequest.options:type_name -> ateapi.DeleteOptions - 32, // 125: ateapi.DrainWorkerRequest.worker:type_name -> ateapi.ObjectRef - 111, // 126: ateapi.DrainWorkerResponse.worker:type_name -> ateapi.Worker - 32, // 127: ateapi.MarkWorkerAvailableRequest.worker:type_name -> ateapi.ObjectRef - 111, // 128: ateapi.MarkWorkerAvailableResponse.worker:type_name -> ateapi.Worker - 32, // 129: ateapi.MarkWorkerUnavailableRequest.worker:type_name -> ateapi.ObjectRef - 111, // 130: ateapi.MarkWorkerUnavailableResponse.worker:type_name -> ateapi.Worker - 94, // 131: ateapi.ListActorsRequest.options:type_name -> ateapi.ListOptions - 15, // 132: ateapi.ListActorsResponse.actors:type_name -> ateapi.Actor - 13, // 133: ateapi.Worker.metadata:type_name -> ateapi.ResourceMetadata - 143, // 134: ateapi.Worker.labels:type_name -> ateapi.Worker.LabelsEntry - 112, // 135: ateapi.Worker.status:type_name -> ateapi.WorkerStatus - 7, // 136: ateapi.WorkerStatus.state:type_name -> ateapi.WorkerState - 116, // 137: ateapi.WorkerStatus.capacity:type_name -> ateapi.WorkerResources - 116, // 138: ateapi.WorkerStatus.allocated:type_name -> ateapi.WorkerResources - 113, // 139: ateapi.WorkerStatus.default_runtime:type_name -> ateapi.SandboxRuntime - 113, // 140: ateapi.WorkerStatus.restorable_runtimes:type_name -> ateapi.SandboxRuntime - 114, // 141: ateapi.SandboxRuntime.version:type_name -> ateapi.VersionedSandboxCompat - 115, // 142: ateapi.VersionedSandboxCompat.attributes:type_name -> ateapi.AttributeEntry - 34, // 143: ateapi.WorkerResources.resources:type_name -> ateapi.Resources - 13, // 144: ateapi.ActorAssignment.metadata:type_name -> ateapi.ResourceMetadata - 32, // 145: ateapi.ActorAssignment.actor:type_name -> ateapi.ObjectRef - 34, // 146: ateapi.ActorAssignment.resources:type_name -> ateapi.Resources - 32, // 147: ateapi.RegisterWorkerRequest.worker:type_name -> ateapi.ObjectRef - 116, // 148: ateapi.RegisterWorkerRequest.capacity:type_name -> ateapi.WorkerResources - 113, // 149: ateapi.RegisterWorkerRequest.default_runtime:type_name -> ateapi.SandboxRuntime - 113, // 150: ateapi.RegisterWorkerRequest.restorable_runtimes:type_name -> ateapi.SandboxRuntime - 111, // 151: ateapi.RegisterWorkerResponse.worker:type_name -> ateapi.Worker - 32, // 152: ateapi.MintWorkerActorCertificateRequest.actor:type_name -> ateapi.ObjectRef - 32, // 153: ateapi.MintWorkerActorJwtRequest.actor:type_name -> ateapi.ObjectRef - 144, // 154: ateapi.MintWorkerActorJwtResponse.expire_time:type_name -> google.protobuf.Timestamp - 32, // 155: ateapi.RequestActorSuspendRequest.worker:type_name -> ateapi.ObjectRef - 32, // 156: ateapi.RequestActorSuspendRequest.actor:type_name -> ateapi.ObjectRef - 15, // 157: ateapi.RequestActorSuspendResponse.actor:type_name -> ateapi.Actor - 32, // 158: ateapi.ReportActorSnapshotStateRequest.actor:type_name -> ateapi.ObjectRef - 128, // 159: ateapi.ReportActorSnapshotStateRequest.state:type_name -> ateapi.ActorSnapshotState - 129, // 160: ateapi.ActorSnapshotState.latest_local:type_name -> ateapi.SnapshotReport - 129, // 161: ateapi.ActorSnapshotState.uploading:type_name -> ateapi.SnapshotReport - 129, // 162: ateapi.ActorSnapshotState.latest_durable:type_name -> ateapi.SnapshotReport - 144, // 163: ateapi.ActorSnapshotState.upload_due_time:type_name -> google.protobuf.Timestamp - 2, // 164: ateapi.SnapshotReport.fidelity:type_name -> ateapi.SnapshotFidelity - 9, // 165: ateapi.SnapshotReport.object:type_name -> ateapi.ObjectSnapshot - 144, // 166: ateapi.SnapshotReport.local_commit_time:type_name -> google.protobuf.Timestamp - 144, // 167: ateapi.SnapshotReport.durable_complete_time:type_name -> google.protobuf.Timestamp - 13, // 168: ateapi.AccessPolicy.metadata:type_name -> ateapi.ResourceMetadata - 131, // 169: ateapi.AccessPolicy.bindings:type_name -> ateapi.Binding - 130, // 170: ateapi.CreateGlobalAccessPolicyRequest.access_policy:type_name -> ateapi.AccessPolicy - 130, // 171: ateapi.UpdateGlobalAccessPolicyRequest.access_policy:type_name -> ateapi.AccessPolicy - 32, // 172: ateapi.GetAtespaceAccessPolicyRequest.atespace:type_name -> ateapi.ObjectRef - 32, // 173: ateapi.CreateAtespaceAccessPolicyRequest.atespace:type_name -> ateapi.ObjectRef - 130, // 174: ateapi.CreateAtespaceAccessPolicyRequest.access_policy:type_name -> ateapi.AccessPolicy - 32, // 175: ateapi.UpdateAtespaceAccessPolicyRequest.atespace:type_name -> ateapi.ObjectRef - 130, // 176: ateapi.UpdateAtespaceAccessPolicyRequest.access_policy:type_name -> ateapi.AccessPolicy - 32, // 177: ateapi.DeleteAtespaceAccessPolicyRequest.atespace:type_name -> ateapi.ObjectRef - 93, // 178: ateapi.DeleteAtespaceAccessPolicyRequest.options:type_name -> ateapi.DeleteOptions - 8, // 179: ateapi.ResourceAnnotation.scope:type_name -> ateapi.Scope - 145, // 180: ateapi.resource:extendee -> google.protobuf.MessageOptions - 146, // 181: ateapi.method:extendee -> google.protobuf.MethodOptions - 139, // 182: ateapi.resource:type_name -> ateapi.ResourceAnnotation - 140, // 183: ateapi.method:type_name -> ateapi.MethodAnnotation - 67, // 184: ateapi.Control.GetActor:input_type -> ateapi.GetActorRequest - 68, // 185: ateapi.Control.CreateActor:input_type -> ateapi.CreateActorRequest - 69, // 186: ateapi.Control.UpdateActor:input_type -> ateapi.UpdateActorRequest - 70, // 187: ateapi.Control.SuspendActor:input_type -> ateapi.SuspendActorRequest - 72, // 188: ateapi.Control.PauseActor:input_type -> ateapi.PauseActorRequest - 74, // 189: ateapi.Control.ResumeActor:input_type -> ateapi.ResumeActorRequest - 76, // 190: ateapi.Control.RevertActor:input_type -> ateapi.RevertActorRequest - 78, // 191: ateapi.Control.DeleteActor:input_type -> ateapi.DeleteActorRequest - 79, // 192: ateapi.Control.GetActorEgressPolicy:input_type -> ateapi.GetActorEgressPolicyRequest - 80, // 193: ateapi.Control.CreateActorEgressPolicy:input_type -> ateapi.CreateActorEgressPolicyRequest - 81, // 194: ateapi.Control.UpdateActorEgressPolicy:input_type -> ateapi.UpdateActorEgressPolicyRequest - 82, // 195: ateapi.Control.DeleteActorEgressPolicy:input_type -> ateapi.DeleteActorEgressPolicyRequest - 84, // 196: ateapi.Control.MintActorJwt:input_type -> ateapi.MintActorJwtRequest - 86, // 197: ateapi.Control.MintActorCertificate:input_type -> ateapi.MintActorCertificateRequest - 90, // 198: ateapi.Control.CreateTag:input_type -> ateapi.CreateTagRequest - 83, // 199: ateapi.Control.GetTag:input_type -> ateapi.GetTagRequest - 88, // 200: ateapi.Control.ListTags:input_type -> ateapi.ListTagsRequest - 91, // 201: ateapi.Control.UpdateTag:input_type -> ateapi.UpdateTagRequest - 92, // 202: ateapi.Control.DeleteTag:input_type -> ateapi.DeleteTagRequest - 97, // 203: ateapi.Control.ListWorkers:input_type -> ateapi.ListWorkersRequest - 99, // 204: ateapi.Control.GetWorker:input_type -> ateapi.GetWorkerRequest - 100, // 205: ateapi.Control.CreateWorker:input_type -> ateapi.CreateWorkerRequest - 101, // 206: ateapi.Control.UpdateWorker:input_type -> ateapi.UpdateWorkerRequest - 102, // 207: ateapi.Control.DeleteWorker:input_type -> ateapi.DeleteWorkerRequest - 103, // 208: ateapi.Control.DrainWorker:input_type -> ateapi.DrainWorkerRequest - 105, // 209: ateapi.Control.MarkWorkerAvailable:input_type -> ateapi.MarkWorkerAvailableRequest - 107, // 210: ateapi.Control.MarkWorkerUnavailable:input_type -> ateapi.MarkWorkerUnavailableRequest - 95, // 211: ateapi.Control.ListWorkerActorAssignments:input_type -> ateapi.ListWorkerActorAssignmentsRequest - 109, // 212: ateapi.Control.ListActors:input_type -> ateapi.ListActorsRequest - 57, // 213: ateapi.Control.CreateAtespace:input_type -> ateapi.CreateAtespaceRequest - 58, // 214: ateapi.Control.GetAtespace:input_type -> ateapi.GetAtespaceRequest - 59, // 215: ateapi.Control.ListAtespaces:input_type -> ateapi.ListAtespacesRequest - 61, // 216: ateapi.Control.DeleteAtespace:input_type -> ateapi.DeleteAtespaceRequest - 62, // 217: ateapi.Control.CreateActorTemplate:input_type -> ateapi.CreateActorTemplateRequest - 63, // 218: ateapi.Control.GetActorTemplate:input_type -> ateapi.GetActorTemplateRequest - 64, // 219: ateapi.Control.ListActorTemplates:input_type -> ateapi.ListActorTemplatesRequest - 66, // 220: ateapi.Control.DeleteActorTemplate:input_type -> ateapi.DeleteActorTemplateRequest - 132, // 221: ateapi.Control.GetGlobalAccessPolicy:input_type -> ateapi.GetGlobalAccessPolicyRequest - 133, // 222: ateapi.Control.CreateGlobalAccessPolicy:input_type -> ateapi.CreateGlobalAccessPolicyRequest - 134, // 223: ateapi.Control.UpdateGlobalAccessPolicy:input_type -> ateapi.UpdateGlobalAccessPolicyRequest - 135, // 224: ateapi.Control.GetAtespaceAccessPolicy:input_type -> ateapi.GetAtespaceAccessPolicyRequest - 136, // 225: ateapi.Control.CreateAtespaceAccessPolicy:input_type -> ateapi.CreateAtespaceAccessPolicyRequest - 137, // 226: ateapi.Control.UpdateAtespaceAccessPolicy:input_type -> ateapi.UpdateAtespaceAccessPolicyRequest - 138, // 227: ateapi.Control.DeleteAtespaceAccessPolicy:input_type -> ateapi.DeleteAtespaceAccessPolicyRequest - 118, // 228: ateapi.WorkerService.RegisterWorker:input_type -> ateapi.RegisterWorkerRequest - 120, // 229: ateapi.WorkerService.MintWorkerActorCertificate:input_type -> ateapi.MintWorkerActorCertificateRequest - 122, // 230: ateapi.WorkerService.MintWorkerActorJwt:input_type -> ateapi.MintWorkerActorJwtRequest - 124, // 231: ateapi.WorkerService.RequestActorSuspend:input_type -> ateapi.RequestActorSuspendRequest - 126, // 232: ateapi.WorkerService.ReportActorSnapshotState:input_type -> ateapi.ReportActorSnapshotStateRequest - 15, // 233: ateapi.Control.GetActor:output_type -> ateapi.Actor - 15, // 234: ateapi.Control.CreateActor:output_type -> ateapi.Actor - 15, // 235: ateapi.Control.UpdateActor:output_type -> ateapi.Actor - 71, // 236: ateapi.Control.SuspendActor:output_type -> ateapi.SuspendActorResponse - 73, // 237: ateapi.Control.PauseActor:output_type -> ateapi.PauseActorResponse - 75, // 238: ateapi.Control.ResumeActor:output_type -> ateapi.ResumeActorResponse - 77, // 239: ateapi.Control.RevertActor:output_type -> ateapi.RevertActorResponse - 15, // 240: ateapi.Control.DeleteActor:output_type -> ateapi.Actor - 16, // 241: ateapi.Control.GetActorEgressPolicy:output_type -> ateapi.EgressPolicy - 16, // 242: ateapi.Control.CreateActorEgressPolicy:output_type -> ateapi.EgressPolicy - 16, // 243: ateapi.Control.UpdateActorEgressPolicy:output_type -> ateapi.EgressPolicy - 16, // 244: ateapi.Control.DeleteActorEgressPolicy:output_type -> ateapi.EgressPolicy - 85, // 245: ateapi.Control.MintActorJwt:output_type -> ateapi.MintActorJwtResponse - 87, // 246: ateapi.Control.MintActorCertificate:output_type -> ateapi.MintActorCertificateResponse - 30, // 247: ateapi.Control.CreateTag:output_type -> ateapi.Tag - 30, // 248: ateapi.Control.GetTag:output_type -> ateapi.Tag - 89, // 249: ateapi.Control.ListTags:output_type -> ateapi.ListTagsResponse - 30, // 250: ateapi.Control.UpdateTag:output_type -> ateapi.Tag - 30, // 251: ateapi.Control.DeleteTag:output_type -> ateapi.Tag - 98, // 252: ateapi.Control.ListWorkers:output_type -> ateapi.ListWorkersResponse - 111, // 253: ateapi.Control.GetWorker:output_type -> ateapi.Worker - 111, // 254: ateapi.Control.CreateWorker:output_type -> ateapi.Worker - 111, // 255: ateapi.Control.UpdateWorker:output_type -> ateapi.Worker - 111, // 256: ateapi.Control.DeleteWorker:output_type -> ateapi.Worker - 104, // 257: ateapi.Control.DrainWorker:output_type -> ateapi.DrainWorkerResponse - 106, // 258: ateapi.Control.MarkWorkerAvailable:output_type -> ateapi.MarkWorkerAvailableResponse - 108, // 259: ateapi.Control.MarkWorkerUnavailable:output_type -> ateapi.MarkWorkerUnavailableResponse - 96, // 260: ateapi.Control.ListWorkerActorAssignments:output_type -> ateapi.ListWorkerActorAssignmentsResponse - 110, // 261: ateapi.Control.ListActors:output_type -> ateapi.ListActorsResponse - 31, // 262: ateapi.Control.CreateAtespace:output_type -> ateapi.Atespace - 31, // 263: ateapi.Control.GetAtespace:output_type -> ateapi.Atespace - 60, // 264: ateapi.Control.ListAtespaces:output_type -> ateapi.ListAtespacesResponse - 31, // 265: ateapi.Control.DeleteAtespace:output_type -> ateapi.Atespace - 33, // 266: ateapi.Control.CreateActorTemplate:output_type -> ateapi.ActorTemplate - 33, // 267: ateapi.Control.GetActorTemplate:output_type -> ateapi.ActorTemplate - 65, // 268: ateapi.Control.ListActorTemplates:output_type -> ateapi.ListActorTemplatesResponse - 33, // 269: ateapi.Control.DeleteActorTemplate:output_type -> ateapi.ActorTemplate - 130, // 270: ateapi.Control.GetGlobalAccessPolicy:output_type -> ateapi.AccessPolicy - 130, // 271: ateapi.Control.CreateGlobalAccessPolicy:output_type -> ateapi.AccessPolicy - 130, // 272: ateapi.Control.UpdateGlobalAccessPolicy:output_type -> ateapi.AccessPolicy - 130, // 273: ateapi.Control.GetAtespaceAccessPolicy:output_type -> ateapi.AccessPolicy - 130, // 274: ateapi.Control.CreateAtespaceAccessPolicy:output_type -> ateapi.AccessPolicy - 130, // 275: ateapi.Control.UpdateAtespaceAccessPolicy:output_type -> ateapi.AccessPolicy - 130, // 276: ateapi.Control.DeleteAtespaceAccessPolicy:output_type -> ateapi.AccessPolicy - 119, // 277: ateapi.WorkerService.RegisterWorker:output_type -> ateapi.RegisterWorkerResponse - 121, // 278: ateapi.WorkerService.MintWorkerActorCertificate:output_type -> ateapi.MintWorkerActorCertificateResponse - 123, // 279: ateapi.WorkerService.MintWorkerActorJwt:output_type -> ateapi.MintWorkerActorJwtResponse - 125, // 280: ateapi.WorkerService.RequestActorSuspend:output_type -> ateapi.RequestActorSuspendResponse - 127, // 281: ateapi.WorkerService.ReportActorSnapshotState:output_type -> ateapi.ReportActorSnapshotStateResponse - 233, // [233:282] is the sub-list for method output_type - 184, // [184:233] is the sub-list for method input_type - 182, // [182:184] is the sub-list for extension type_name - 180, // [180:182] is the sub-list for extension extendee - 0, // [0:180] is the sub-list for field type_name + 18, // 16: ateapi.EgressPolicy.rules:type_name -> ateapi.EgressRule + 18, // 17: ateapi.EgressPolicyTemplate.rules:type_name -> ateapi.EgressRule + 19, // 18: ateapi.EgressRule.http:type_name -> ateapi.HttpRule + 20, // 19: ateapi.EgressRule.https:type_name -> ateapi.HttpsRule + 21, // 20: ateapi.EgressRule.tls_passthrough:type_name -> ateapi.TlsPassthroughRule + 22, // 21: ateapi.HttpRule.ports:type_name -> ateapi.Ports + 24, // 22: ateapi.HttpRule.effects:type_name -> ateapi.HttpRuleEffects + 22, // 23: ateapi.HttpsRule.ports:type_name -> ateapi.Ports + 24, // 24: ateapi.HttpsRule.effects:type_name -> ateapi.HttpRuleEffects + 22, // 25: ateapi.TlsPassthroughRule.ports:type_name -> ateapi.Ports + 23, // 26: ateapi.Ports.all:type_name -> ateapi.AllPorts + 25, // 27: ateapi.HttpRuleEffects.replace_headers:type_name -> ateapi.CredentialHeader + 26, // 28: ateapi.CredentialHeader.actor_jwt:type_name -> ateapi.ActorJwtSource + 4, // 29: ateapi.ActorStatus.state:type_name -> ateapi.ActorState + 29, // 30: ateapi.ActorStatus.worker_assignment:type_name -> ateapi.WorkerAssignment + 14, // 31: ateapi.ActorStatus.external_volumes:type_name -> ateapi.ExternalVolume + 28, // 32: ateapi.ActorStatus.crash:type_name -> ateapi.ActorCrash + 11, // 33: ateapi.ActorStatus.snapshots:type_name -> ateapi.Snapshot + 145, // 34: ateapi.ActorCrash.crash_time:type_name -> google.protobuf.Timestamp + 33, // 35: ateapi.WorkerAssignment.worker:type_name -> ateapi.ObjectRef + 114, // 36: ateapi.WorkerAssignment.sandbox_runtime:type_name -> ateapi.SandboxRuntime + 11, // 37: ateapi.TagStatus.snapshot:type_name -> ateapi.Snapshot + 13, // 38: ateapi.Tag.metadata:type_name -> ateapi.ResourceMetadata + 30, // 39: ateapi.Tag.status:type_name -> ateapi.TagStatus + 3, // 40: ateapi.Tag.scope:type_name -> ateapi.TagScope + 33, // 41: ateapi.Tag.source_actor:type_name -> ateapi.ObjectRef + 13, // 42: ateapi.Atespace.metadata:type_name -> ateapi.ResourceMetadata + 13, // 43: ateapi.ActorTemplate.metadata:type_name -> ateapi.ResourceMetadata + 12, // 44: ateapi.ActorTemplate.worker_selector:type_name -> ateapi.Selector + 42, // 45: ateapi.ActorTemplate.containers:type_name -> ateapi.Container + 48, // 46: ateapi.ActorTemplate.volumes:type_name -> ateapi.Volume + 40, // 47: ateapi.ActorTemplate.snapshot_config:type_name -> ateapi.SnapshotConfig + 39, // 48: ateapi.ActorTemplate.sandbox_config:type_name -> ateapi.SandboxConfig + 35, // 49: ateapi.ActorTemplate.resources:type_name -> ateapi.Resources + 38, // 50: ateapi.ActorTemplate.status:type_name -> ateapi.ActorTemplateStatus + 17, // 51: ateapi.ActorTemplate.golden_egress_policy:type_name -> ateapi.EgressPolicyTemplate + 36, // 52: ateapi.Resources.limits:type_name -> ateapi.Limits + 33, // 53: ateapi.GoldenSnapshotStatus.golden_tag:type_name -> ateapi.ObjectRef + 145, // 54: ateapi.GoldenSnapshotStatus.snapshot_time:type_name -> google.protobuf.Timestamp + 37, // 55: ateapi.ActorTemplateStatus.golden_snapshot_status:type_name -> ateapi.GoldenSnapshotStatus + 2, // 56: ateapi.SnapshotConfig.preferred_fidelity:type_name -> ateapi.SnapshotFidelity + 41, // 57: ateapi.SnapshotConfig.golden_snapshot_config:type_name -> ateapi.GoldenSnapshotConfig + 5, // 58: ateapi.GoldenSnapshotConfig.mode:type_name -> ateapi.GoldenSnapshotMode + 45, // 59: ateapi.Container.env:type_name -> ateapi.EnvVar + 46, // 60: ateapi.Container.wakeup_probe:type_name -> ateapi.WakeupProbe + 57, // 61: ateapi.Container.volume_mounts:type_name -> ateapi.VolumeMount + 43, // 62: ateapi.Container.security_context:type_name -> ateapi.SecurityContext + 35, // 63: ateapi.Container.resources:type_name -> ateapi.Resources + 44, // 64: ateapi.SecurityContext.capabilities:type_name -> ateapi.Capabilities + 47, // 65: ateapi.WakeupProbe.http_get:type_name -> ateapi.HttpGetAction + 50, // 66: ateapi.Volume.durable_dir:type_name -> ateapi.DurableDirVolumeSource + 51, // 67: ateapi.Volume.external_volume_template:type_name -> ateapi.ExternalVolumeTemplate + 52, // 68: ateapi.Volume.system_info:type_name -> ateapi.SystemInfoVolumeSource + 49, // 69: ateapi.Volume.image:type_name -> ateapi.ImageVolumeSource + 53, // 70: ateapi.SystemInfoVolumeSource.data_sources:type_name -> ateapi.SystemInfoDataSource + 54, // 71: ateapi.SystemInfoDataSource.actor_metadata:type_name -> ateapi.ActorMetadataDataSource + 56, // 72: ateapi.SystemInfoDataSource.trust_bundle:type_name -> ateapi.TrustBundleDataSource + 55, // 73: ateapi.ActorMetadataDataSource.items:type_name -> ateapi.ActorMetadataItem + 6, // 74: ateapi.ActorMetadataItem.field:type_name -> ateapi.ActorMetadataField + 32, // 75: ateapi.CreateAtespaceRequest.atespace:type_name -> ateapi.Atespace + 33, // 76: ateapi.GetAtespaceRequest.atespace:type_name -> ateapi.ObjectRef + 95, // 77: ateapi.ListAtespacesRequest.options:type_name -> ateapi.ListOptions + 32, // 78: ateapi.ListAtespacesResponse.atespaces:type_name -> ateapi.Atespace + 33, // 79: ateapi.DeleteAtespaceRequest.atespace:type_name -> ateapi.ObjectRef + 94, // 80: ateapi.DeleteAtespaceRequest.options:type_name -> ateapi.DeleteOptions + 34, // 81: ateapi.CreateActorTemplateRequest.actor_template:type_name -> ateapi.ActorTemplate + 33, // 82: ateapi.GetActorTemplateRequest.actor_template:type_name -> ateapi.ObjectRef + 95, // 83: ateapi.ListActorTemplatesRequest.options:type_name -> ateapi.ListOptions + 34, // 84: ateapi.ListActorTemplatesResponse.actor_templates:type_name -> ateapi.ActorTemplate + 33, // 85: ateapi.DeleteActorTemplateRequest.actor_template:type_name -> ateapi.ObjectRef + 94, // 86: ateapi.DeleteActorTemplateRequest.options:type_name -> ateapi.DeleteOptions + 33, // 87: ateapi.GetActorRequest.actor:type_name -> ateapi.ObjectRef + 15, // 88: ateapi.CreateActorRequest.actor:type_name -> ateapi.Actor + 16, // 89: ateapi.CreateActorRequest.initial_egress_policy:type_name -> ateapi.EgressPolicy + 15, // 90: ateapi.UpdateActorRequest.actor:type_name -> ateapi.Actor + 33, // 91: ateapi.SuspendActorRequest.actor:type_name -> ateapi.ObjectRef + 15, // 92: ateapi.SuspendActorResponse.actor:type_name -> ateapi.Actor + 33, // 93: ateapi.PauseActorRequest.actor:type_name -> ateapi.ObjectRef + 15, // 94: ateapi.PauseActorResponse.actor:type_name -> ateapi.Actor + 33, // 95: ateapi.ResumeActorRequest.actor:type_name -> ateapi.ObjectRef + 15, // 96: ateapi.ResumeActorResponse.actor:type_name -> ateapi.Actor + 33, // 97: ateapi.RevertActorRequest.actor:type_name -> ateapi.ObjectRef + 15, // 98: ateapi.RevertActorResponse.actor:type_name -> ateapi.Actor + 33, // 99: ateapi.DeleteActorRequest.actor:type_name -> ateapi.ObjectRef + 94, // 100: ateapi.DeleteActorRequest.options:type_name -> ateapi.DeleteOptions + 33, // 101: ateapi.GetActorEgressPolicyRequest.actor:type_name -> ateapi.ObjectRef + 33, // 102: ateapi.CreateActorEgressPolicyRequest.actor:type_name -> ateapi.ObjectRef + 16, // 103: ateapi.CreateActorEgressPolicyRequest.egress_policy:type_name -> ateapi.EgressPolicy + 33, // 104: ateapi.UpdateActorEgressPolicyRequest.actor:type_name -> ateapi.ObjectRef + 16, // 105: ateapi.UpdateActorEgressPolicyRequest.egress_policy:type_name -> ateapi.EgressPolicy + 33, // 106: ateapi.DeleteActorEgressPolicyRequest.actor:type_name -> ateapi.ObjectRef + 94, // 107: ateapi.DeleteActorEgressPolicyRequest.options:type_name -> ateapi.DeleteOptions + 33, // 108: ateapi.GetTagRequest.tag:type_name -> ateapi.ObjectRef + 33, // 109: ateapi.MintActorJwtRequest.actor:type_name -> ateapi.ObjectRef + 145, // 110: ateapi.MintActorJwtResponse.expire_time:type_name -> google.protobuf.Timestamp + 33, // 111: ateapi.MintActorCertificateRequest.actor:type_name -> ateapi.ObjectRef + 95, // 112: ateapi.ListTagsRequest.options:type_name -> ateapi.ListOptions + 31, // 113: ateapi.ListTagsResponse.tags:type_name -> ateapi.Tag + 31, // 114: ateapi.CreateTagRequest.tag:type_name -> ateapi.Tag + 31, // 115: ateapi.UpdateTagRequest.tag:type_name -> ateapi.Tag + 33, // 116: ateapi.DeleteTagRequest.tag:type_name -> ateapi.ObjectRef + 94, // 117: ateapi.DeleteTagRequest.options:type_name -> ateapi.DeleteOptions + 33, // 118: ateapi.ListWorkerActorAssignmentsRequest.worker:type_name -> ateapi.ObjectRef + 95, // 119: ateapi.ListWorkerActorAssignmentsRequest.options:type_name -> ateapi.ListOptions + 118, // 120: ateapi.ListWorkerActorAssignmentsResponse.actor_assignments:type_name -> ateapi.ActorAssignment + 95, // 121: ateapi.ListWorkersRequest.options:type_name -> ateapi.ListOptions + 112, // 122: ateapi.ListWorkersResponse.workers:type_name -> ateapi.Worker + 33, // 123: ateapi.GetWorkerRequest.worker:type_name -> ateapi.ObjectRef + 112, // 124: ateapi.CreateWorkerRequest.worker:type_name -> ateapi.Worker + 112, // 125: ateapi.UpdateWorkerRequest.worker:type_name -> ateapi.Worker + 33, // 126: ateapi.DeleteWorkerRequest.worker:type_name -> ateapi.ObjectRef + 94, // 127: ateapi.DeleteWorkerRequest.options:type_name -> ateapi.DeleteOptions + 33, // 128: ateapi.DrainWorkerRequest.worker:type_name -> ateapi.ObjectRef + 112, // 129: ateapi.DrainWorkerResponse.worker:type_name -> ateapi.Worker + 33, // 130: ateapi.MarkWorkerAvailableRequest.worker:type_name -> ateapi.ObjectRef + 112, // 131: ateapi.MarkWorkerAvailableResponse.worker:type_name -> ateapi.Worker + 33, // 132: ateapi.MarkWorkerUnavailableRequest.worker:type_name -> ateapi.ObjectRef + 112, // 133: ateapi.MarkWorkerUnavailableResponse.worker:type_name -> ateapi.Worker + 95, // 134: ateapi.ListActorsRequest.options:type_name -> ateapi.ListOptions + 15, // 135: ateapi.ListActorsResponse.actors:type_name -> ateapi.Actor + 13, // 136: ateapi.Worker.metadata:type_name -> ateapi.ResourceMetadata + 144, // 137: ateapi.Worker.labels:type_name -> ateapi.Worker.LabelsEntry + 113, // 138: ateapi.Worker.status:type_name -> ateapi.WorkerStatus + 7, // 139: ateapi.WorkerStatus.state:type_name -> ateapi.WorkerState + 117, // 140: ateapi.WorkerStatus.capacity:type_name -> ateapi.WorkerResources + 117, // 141: ateapi.WorkerStatus.allocated:type_name -> ateapi.WorkerResources + 114, // 142: ateapi.WorkerStatus.default_runtime:type_name -> ateapi.SandboxRuntime + 114, // 143: ateapi.WorkerStatus.restorable_runtimes:type_name -> ateapi.SandboxRuntime + 115, // 144: ateapi.SandboxRuntime.version:type_name -> ateapi.VersionedSandboxCompat + 116, // 145: ateapi.VersionedSandboxCompat.attributes:type_name -> ateapi.AttributeEntry + 35, // 146: ateapi.WorkerResources.resources:type_name -> ateapi.Resources + 13, // 147: ateapi.ActorAssignment.metadata:type_name -> ateapi.ResourceMetadata + 33, // 148: ateapi.ActorAssignment.actor:type_name -> ateapi.ObjectRef + 35, // 149: ateapi.ActorAssignment.resources:type_name -> ateapi.Resources + 33, // 150: ateapi.RegisterWorkerRequest.worker:type_name -> ateapi.ObjectRef + 117, // 151: ateapi.RegisterWorkerRequest.capacity:type_name -> ateapi.WorkerResources + 114, // 152: ateapi.RegisterWorkerRequest.default_runtime:type_name -> ateapi.SandboxRuntime + 114, // 153: ateapi.RegisterWorkerRequest.restorable_runtimes:type_name -> ateapi.SandboxRuntime + 112, // 154: ateapi.RegisterWorkerResponse.worker:type_name -> ateapi.Worker + 33, // 155: ateapi.MintWorkerActorCertificateRequest.actor:type_name -> ateapi.ObjectRef + 33, // 156: ateapi.MintWorkerActorJwtRequest.actor:type_name -> ateapi.ObjectRef + 145, // 157: ateapi.MintWorkerActorJwtResponse.expire_time:type_name -> google.protobuf.Timestamp + 33, // 158: ateapi.RequestActorSuspendRequest.worker:type_name -> ateapi.ObjectRef + 33, // 159: ateapi.RequestActorSuspendRequest.actor:type_name -> ateapi.ObjectRef + 15, // 160: ateapi.RequestActorSuspendResponse.actor:type_name -> ateapi.Actor + 33, // 161: ateapi.ReportActorSnapshotStateRequest.actor:type_name -> ateapi.ObjectRef + 129, // 162: ateapi.ReportActorSnapshotStateRequest.state:type_name -> ateapi.ActorSnapshotState + 130, // 163: ateapi.ActorSnapshotState.latest_local:type_name -> ateapi.SnapshotReport + 130, // 164: ateapi.ActorSnapshotState.uploading:type_name -> ateapi.SnapshotReport + 130, // 165: ateapi.ActorSnapshotState.latest_durable:type_name -> ateapi.SnapshotReport + 145, // 166: ateapi.ActorSnapshotState.upload_due_time:type_name -> google.protobuf.Timestamp + 2, // 167: ateapi.SnapshotReport.fidelity:type_name -> ateapi.SnapshotFidelity + 9, // 168: ateapi.SnapshotReport.object:type_name -> ateapi.ObjectSnapshot + 145, // 169: ateapi.SnapshotReport.local_commit_time:type_name -> google.protobuf.Timestamp + 145, // 170: ateapi.SnapshotReport.durable_complete_time:type_name -> google.protobuf.Timestamp + 13, // 171: ateapi.AccessPolicy.metadata:type_name -> ateapi.ResourceMetadata + 132, // 172: ateapi.AccessPolicy.bindings:type_name -> ateapi.Binding + 131, // 173: ateapi.CreateGlobalAccessPolicyRequest.access_policy:type_name -> ateapi.AccessPolicy + 131, // 174: ateapi.UpdateGlobalAccessPolicyRequest.access_policy:type_name -> ateapi.AccessPolicy + 33, // 175: ateapi.GetAtespaceAccessPolicyRequest.atespace:type_name -> ateapi.ObjectRef + 33, // 176: ateapi.CreateAtespaceAccessPolicyRequest.atespace:type_name -> ateapi.ObjectRef + 131, // 177: ateapi.CreateAtespaceAccessPolicyRequest.access_policy:type_name -> ateapi.AccessPolicy + 33, // 178: ateapi.UpdateAtespaceAccessPolicyRequest.atespace:type_name -> ateapi.ObjectRef + 131, // 179: ateapi.UpdateAtespaceAccessPolicyRequest.access_policy:type_name -> ateapi.AccessPolicy + 33, // 180: ateapi.DeleteAtespaceAccessPolicyRequest.atespace:type_name -> ateapi.ObjectRef + 94, // 181: ateapi.DeleteAtespaceAccessPolicyRequest.options:type_name -> ateapi.DeleteOptions + 8, // 182: ateapi.ResourceAnnotation.scope:type_name -> ateapi.Scope + 146, // 183: ateapi.resource:extendee -> google.protobuf.MessageOptions + 147, // 184: ateapi.method:extendee -> google.protobuf.MethodOptions + 140, // 185: ateapi.resource:type_name -> ateapi.ResourceAnnotation + 141, // 186: ateapi.method:type_name -> ateapi.MethodAnnotation + 68, // 187: ateapi.Control.GetActor:input_type -> ateapi.GetActorRequest + 69, // 188: ateapi.Control.CreateActor:input_type -> ateapi.CreateActorRequest + 70, // 189: ateapi.Control.UpdateActor:input_type -> ateapi.UpdateActorRequest + 71, // 190: ateapi.Control.SuspendActor:input_type -> ateapi.SuspendActorRequest + 73, // 191: ateapi.Control.PauseActor:input_type -> ateapi.PauseActorRequest + 75, // 192: ateapi.Control.ResumeActor:input_type -> ateapi.ResumeActorRequest + 77, // 193: ateapi.Control.RevertActor:input_type -> ateapi.RevertActorRequest + 79, // 194: ateapi.Control.DeleteActor:input_type -> ateapi.DeleteActorRequest + 80, // 195: ateapi.Control.GetActorEgressPolicy:input_type -> ateapi.GetActorEgressPolicyRequest + 81, // 196: ateapi.Control.CreateActorEgressPolicy:input_type -> ateapi.CreateActorEgressPolicyRequest + 82, // 197: ateapi.Control.UpdateActorEgressPolicy:input_type -> ateapi.UpdateActorEgressPolicyRequest + 83, // 198: ateapi.Control.DeleteActorEgressPolicy:input_type -> ateapi.DeleteActorEgressPolicyRequest + 85, // 199: ateapi.Control.MintActorJwt:input_type -> ateapi.MintActorJwtRequest + 87, // 200: ateapi.Control.MintActorCertificate:input_type -> ateapi.MintActorCertificateRequest + 91, // 201: ateapi.Control.CreateTag:input_type -> ateapi.CreateTagRequest + 84, // 202: ateapi.Control.GetTag:input_type -> ateapi.GetTagRequest + 89, // 203: ateapi.Control.ListTags:input_type -> ateapi.ListTagsRequest + 92, // 204: ateapi.Control.UpdateTag:input_type -> ateapi.UpdateTagRequest + 93, // 205: ateapi.Control.DeleteTag:input_type -> ateapi.DeleteTagRequest + 98, // 206: ateapi.Control.ListWorkers:input_type -> ateapi.ListWorkersRequest + 100, // 207: ateapi.Control.GetWorker:input_type -> ateapi.GetWorkerRequest + 101, // 208: ateapi.Control.CreateWorker:input_type -> ateapi.CreateWorkerRequest + 102, // 209: ateapi.Control.UpdateWorker:input_type -> ateapi.UpdateWorkerRequest + 103, // 210: ateapi.Control.DeleteWorker:input_type -> ateapi.DeleteWorkerRequest + 104, // 211: ateapi.Control.DrainWorker:input_type -> ateapi.DrainWorkerRequest + 106, // 212: ateapi.Control.MarkWorkerAvailable:input_type -> ateapi.MarkWorkerAvailableRequest + 108, // 213: ateapi.Control.MarkWorkerUnavailable:input_type -> ateapi.MarkWorkerUnavailableRequest + 96, // 214: ateapi.Control.ListWorkerActorAssignments:input_type -> ateapi.ListWorkerActorAssignmentsRequest + 110, // 215: ateapi.Control.ListActors:input_type -> ateapi.ListActorsRequest + 58, // 216: ateapi.Control.CreateAtespace:input_type -> ateapi.CreateAtespaceRequest + 59, // 217: ateapi.Control.GetAtespace:input_type -> ateapi.GetAtespaceRequest + 60, // 218: ateapi.Control.ListAtespaces:input_type -> ateapi.ListAtespacesRequest + 62, // 219: ateapi.Control.DeleteAtespace:input_type -> ateapi.DeleteAtespaceRequest + 63, // 220: ateapi.Control.CreateActorTemplate:input_type -> ateapi.CreateActorTemplateRequest + 64, // 221: ateapi.Control.GetActorTemplate:input_type -> ateapi.GetActorTemplateRequest + 65, // 222: ateapi.Control.ListActorTemplates:input_type -> ateapi.ListActorTemplatesRequest + 67, // 223: ateapi.Control.DeleteActorTemplate:input_type -> ateapi.DeleteActorTemplateRequest + 133, // 224: ateapi.Control.GetGlobalAccessPolicy:input_type -> ateapi.GetGlobalAccessPolicyRequest + 134, // 225: ateapi.Control.CreateGlobalAccessPolicy:input_type -> ateapi.CreateGlobalAccessPolicyRequest + 135, // 226: ateapi.Control.UpdateGlobalAccessPolicy:input_type -> ateapi.UpdateGlobalAccessPolicyRequest + 136, // 227: ateapi.Control.GetAtespaceAccessPolicy:input_type -> ateapi.GetAtespaceAccessPolicyRequest + 137, // 228: ateapi.Control.CreateAtespaceAccessPolicy:input_type -> ateapi.CreateAtespaceAccessPolicyRequest + 138, // 229: ateapi.Control.UpdateAtespaceAccessPolicy:input_type -> ateapi.UpdateAtespaceAccessPolicyRequest + 139, // 230: ateapi.Control.DeleteAtespaceAccessPolicy:input_type -> ateapi.DeleteAtespaceAccessPolicyRequest + 119, // 231: ateapi.WorkerService.RegisterWorker:input_type -> ateapi.RegisterWorkerRequest + 121, // 232: ateapi.WorkerService.MintWorkerActorCertificate:input_type -> ateapi.MintWorkerActorCertificateRequest + 123, // 233: ateapi.WorkerService.MintWorkerActorJwt:input_type -> ateapi.MintWorkerActorJwtRequest + 125, // 234: ateapi.WorkerService.RequestActorSuspend:input_type -> ateapi.RequestActorSuspendRequest + 127, // 235: ateapi.WorkerService.ReportActorSnapshotState:input_type -> ateapi.ReportActorSnapshotStateRequest + 15, // 236: ateapi.Control.GetActor:output_type -> ateapi.Actor + 15, // 237: ateapi.Control.CreateActor:output_type -> ateapi.Actor + 15, // 238: ateapi.Control.UpdateActor:output_type -> ateapi.Actor + 72, // 239: ateapi.Control.SuspendActor:output_type -> ateapi.SuspendActorResponse + 74, // 240: ateapi.Control.PauseActor:output_type -> ateapi.PauseActorResponse + 76, // 241: ateapi.Control.ResumeActor:output_type -> ateapi.ResumeActorResponse + 78, // 242: ateapi.Control.RevertActor:output_type -> ateapi.RevertActorResponse + 15, // 243: ateapi.Control.DeleteActor:output_type -> ateapi.Actor + 16, // 244: ateapi.Control.GetActorEgressPolicy:output_type -> ateapi.EgressPolicy + 16, // 245: ateapi.Control.CreateActorEgressPolicy:output_type -> ateapi.EgressPolicy + 16, // 246: ateapi.Control.UpdateActorEgressPolicy:output_type -> ateapi.EgressPolicy + 16, // 247: ateapi.Control.DeleteActorEgressPolicy:output_type -> ateapi.EgressPolicy + 86, // 248: ateapi.Control.MintActorJwt:output_type -> ateapi.MintActorJwtResponse + 88, // 249: ateapi.Control.MintActorCertificate:output_type -> ateapi.MintActorCertificateResponse + 31, // 250: ateapi.Control.CreateTag:output_type -> ateapi.Tag + 31, // 251: ateapi.Control.GetTag:output_type -> ateapi.Tag + 90, // 252: ateapi.Control.ListTags:output_type -> ateapi.ListTagsResponse + 31, // 253: ateapi.Control.UpdateTag:output_type -> ateapi.Tag + 31, // 254: ateapi.Control.DeleteTag:output_type -> ateapi.Tag + 99, // 255: ateapi.Control.ListWorkers:output_type -> ateapi.ListWorkersResponse + 112, // 256: ateapi.Control.GetWorker:output_type -> ateapi.Worker + 112, // 257: ateapi.Control.CreateWorker:output_type -> ateapi.Worker + 112, // 258: ateapi.Control.UpdateWorker:output_type -> ateapi.Worker + 112, // 259: ateapi.Control.DeleteWorker:output_type -> ateapi.Worker + 105, // 260: ateapi.Control.DrainWorker:output_type -> ateapi.DrainWorkerResponse + 107, // 261: ateapi.Control.MarkWorkerAvailable:output_type -> ateapi.MarkWorkerAvailableResponse + 109, // 262: ateapi.Control.MarkWorkerUnavailable:output_type -> ateapi.MarkWorkerUnavailableResponse + 97, // 263: ateapi.Control.ListWorkerActorAssignments:output_type -> ateapi.ListWorkerActorAssignmentsResponse + 111, // 264: ateapi.Control.ListActors:output_type -> ateapi.ListActorsResponse + 32, // 265: ateapi.Control.CreateAtespace:output_type -> ateapi.Atespace + 32, // 266: ateapi.Control.GetAtespace:output_type -> ateapi.Atespace + 61, // 267: ateapi.Control.ListAtespaces:output_type -> ateapi.ListAtespacesResponse + 32, // 268: ateapi.Control.DeleteAtespace:output_type -> ateapi.Atespace + 34, // 269: ateapi.Control.CreateActorTemplate:output_type -> ateapi.ActorTemplate + 34, // 270: ateapi.Control.GetActorTemplate:output_type -> ateapi.ActorTemplate + 66, // 271: ateapi.Control.ListActorTemplates:output_type -> ateapi.ListActorTemplatesResponse + 34, // 272: ateapi.Control.DeleteActorTemplate:output_type -> ateapi.ActorTemplate + 131, // 273: ateapi.Control.GetGlobalAccessPolicy:output_type -> ateapi.AccessPolicy + 131, // 274: ateapi.Control.CreateGlobalAccessPolicy:output_type -> ateapi.AccessPolicy + 131, // 275: ateapi.Control.UpdateGlobalAccessPolicy:output_type -> ateapi.AccessPolicy + 131, // 276: ateapi.Control.GetAtespaceAccessPolicy:output_type -> ateapi.AccessPolicy + 131, // 277: ateapi.Control.CreateAtespaceAccessPolicy:output_type -> ateapi.AccessPolicy + 131, // 278: ateapi.Control.UpdateAtespaceAccessPolicy:output_type -> ateapi.AccessPolicy + 131, // 279: ateapi.Control.DeleteAtespaceAccessPolicy:output_type -> ateapi.AccessPolicy + 120, // 280: ateapi.WorkerService.RegisterWorker:output_type -> ateapi.RegisterWorkerResponse + 122, // 281: ateapi.WorkerService.MintWorkerActorCertificate:output_type -> ateapi.MintWorkerActorCertificateResponse + 124, // 282: ateapi.WorkerService.MintWorkerActorJwt:output_type -> ateapi.MintWorkerActorJwtResponse + 126, // 283: ateapi.WorkerService.RequestActorSuspend:output_type -> ateapi.RequestActorSuspendResponse + 128, // 284: ateapi.WorkerService.ReportActorSnapshotState:output_type -> ateapi.ReportActorSnapshotStateResponse + 236, // [236:285] is the sub-list for method output_type + 187, // [187:236] is the sub-list for method input_type + 185, // [185:187] is the sub-list for extension type_name + 183, // [183:185] is the sub-list for extension extendee + 0, // [0:183] is the sub-list for field type_name } func init() { file_ateapi_proto_init() } @@ -10438,7 +10539,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: 9, - NumMessages: 135, + NumMessages: 136, NumExtensions: 2, NumServices: 2, }, diff --git a/pkg/proto/ateapipb/ateapi.proto b/pkg/proto/ateapipb/ateapi.proto index 233b3fb63e..9c9e4553aa 100644 --- a/pkg/proto/ateapipb/ateapi.proto +++ b/pkg/proto/ateapipb/ateapi.proto @@ -614,6 +614,21 @@ message EgressPolicy { repeated EgressRule rules = 2; } +// EgressPolicyTemplate defines an initial Actor egress policy without resource +// metadata. Each rule has the same defaults, validation, and semantics as +// EgressPolicy.rules. +message EgressPolicyTemplate { + // Rules are an unordered set of allows, with the same precedence and effects + // as EgressPolicy.rules. At least one rule is required. Traffic is denied + // when no rule matches. + // + // +k8s:required + // +k8s:maxItems=256 + // +k8s:listType=atomic + // +k8s:customValidation # no two rules tie on a name and port + repeated EgressRule rules = 1; +} + // EgressRule allows traffic for a given protocol and destination (host name // or IP, and port). The protocol fixes what the gateway matches on and when: // a request, or a TLS connection at its ClientHello. Traffic that matches no @@ -1152,6 +1167,18 @@ message ActorTemplate { // +k8s:optional ActorTemplateStatus status = 8; + + // Egress policy for the golden Actor during initialization. The template + // controller supplies a policy with these rules and generated metadata + // as CreateActorRequest.initial_egress_policy + // when creating the golden Actor. Other Actors created from this template + // do not inherit this policy, including when using the golden snapshot. + // If absent, no policy is created. When set, at least one rule is required. + // + // +ate:preview=GoldenEgressPolicy + // +k8s:ifDisabled(GoldenEgressPolicy)=+k8s:forbidden + // +k8s:optional + EgressPolicyTemplate golden_egress_policy = 9; } message Resources { @@ -1719,11 +1746,25 @@ message GetActorRequest { } // Request to create a new Actor. +// +// +k8s:customValidation # initial policy must match the actor's atespace and contain rules message CreateActorRequest { // The actor to create. // // +k8s:required Actor actor = 1; + + // Optional initial egress policy, created atomically with the Actor as its + // "default" policy. metadata.name must be "default" and metadata.atespace + // must match actor.metadata.atespace. UID, version, and timestamps are + // server-managed. When set, at least one rule is required, and the caller + // must have permission to create an egress policy on the Actor in addition + // to creating the Actor. + // If absent, no policy is created or inherited from the template or tag. + // The policy can subsequently be managed through the Actor egress policy RPCs. + // + // +k8s:optional + EgressPolicy initial_egress_policy = 2; } // Request to update mutable fields on an existing Actor. diff --git a/tools/apitool/exemptions.json b/tools/apitool/exemptions.json index 1664fa468b..fd3da89f78 100644 --- a/tools/apitool/exemptions.json +++ b/tools/apitool/exemptions.json @@ -1,4 +1,9 @@ [ + { + "rule": "create-request-shape", + "subject": "ateapi.Control.CreateActor", + "message": "request field \"initial_egress_policy\" is not allowed - want only \"actor\" ateapi.Actor and optional \"options\" ateapi.CreateOptions" + }, { "rule": "delete-request-shape", "subject": "ateapi.Control.DeleteActor",