diff --git a/cmd/ateapi/internal/controlapi/egress_policy.go b/cmd/ateapi/internal/controlapi/egress_policy.go new file mode 100644 index 000000000..ac78f7f8b --- /dev/null +++ b/cmd/ateapi/internal/controlapi/egress_policy.go @@ -0,0 +1,350 @@ +// 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" + "fmt" + "net/netip" + "net/url" + "strings" + + "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/grpc/codes" + "google.golang.org/grpc/status" + "google.golang.org/protobuf/proto" + "k8s.io/apimachinery/pkg/api/operation" + "k8s.io/apimachinery/pkg/util/validation" + "k8s.io/apimachinery/pkg/util/validation/field" +) + +func (s *RPCService) GetActorEgressPolicy(ctx context.Context, req *ateapipb.GetActorEgressPolicyRequest) (*ateapipb.EgressPolicy, error) { + if errs := Validate_GetActorEgressPolicyRequest(ctx, operation.Operation{Type: operation.Create}, nil, req, nil); len(errs) > 0 { + return nil, toGRPCStatusError(errs) + } + policy, err := s.impl.GetEgressPolicy(ctx, resources.ActorRefFromObjectRef(req.GetActor())) + if errors.Is(err, store.ErrNotFound) { + return nil, status.Error(codes.NotFound, "EgressPolicy not found") + } + if err != nil { + return nil, fmt.Errorf("while getting Actor egress policy: %w", err) + } + return policy, nil +} + +func (s *RPCService) CreateActorEgressPolicy(ctx context.Context, req *ateapipb.CreateActorEgressPolicyRequest) (*ateapipb.EgressPolicy, error) { + policy := req.GetEgressPolicy() + if policy != nil { + scrubResourceMetadataForCreate(policy.Metadata) + } + if errs := validateCreateActorEgressPolicyRequest(ctx, req); len(errs) > 0 { + return nil, toGRPCStatusError(errs) + } + actorRef := resources.ActorRefFromObjectRef(req.GetActor()) + in := normalizeEgressPolicy(policy) + created, err := s.impl.CreateEgressPolicy(ctx, actorRef, in) + return mapEgressPolicyWrite(created, err) +} + +func (s *RPCService) UpdateActorEgressPolicy(ctx context.Context, req *ateapipb.UpdateActorEgressPolicyRequest) (*ateapipb.EgressPolicy, error) { + policy := req.GetEgressPolicy() + if policy != nil { + scrubResourceMetadataForUpdate(policy.Metadata) + } + if errs := validateUpdateActorEgressPolicyRequest(ctx, req); len(errs) > 0 { + return nil, toGRPCStatusError(errs) + } + actorRef := resources.ActorRefFromObjectRef(req.GetActor()) + in := normalizeEgressPolicy(policy) + updated, err := s.impl.UpdateEgressPolicy(ctx, actorRef, store.PreconditionFrom(in), func(toUpdate *ateapipb.EgressPolicy) error { + toUpdate.Rules = in.GetRules() + return nil + }) + return mapEgressPolicyWrite(updated, err) +} + +func (s *RPCService) DeleteActorEgressPolicy(ctx context.Context, req *ateapipb.DeleteActorEgressPolicyRequest) (*ateapipb.EgressPolicy, error) { + if errs := Validate_DeleteActorEgressPolicyRequest(ctx, operation.Operation{Type: operation.Create}, nil, req, nil); len(errs) > 0 { + return nil, toGRPCStatusError(errs) + } + policy, err := s.impl.DeleteEgressPolicy(ctx, resources.ActorRefFromObjectRef(req.GetActor())) + return mapEgressPolicyWrite(policy, err) +} + +func (s *ServiceImpl) CreateEgressPolicy(ctx context.Context, actorRef resources.ActorRef, policy *ateapipb.EgressPolicy) (*ateapipb.EgressPolicy, error) { + return s.store.CreateEgressPolicy(ctx, actorRef, policy) +} + +func (s *ServiceImpl) GetEgressPolicy(ctx context.Context, actorRef resources.ActorRef) (*ateapipb.EgressPolicy, error) { + return s.store.GetEgressPolicy(ctx, actorRef) +} + +func (s *ServiceImpl) UpdateEgressPolicy(ctx context.Context, actorRef resources.ActorRef, precondition store.Precondition, mutate func(*ateapipb.EgressPolicy) error) (*ateapipb.EgressPolicy, error) { + return s.store.UpdateEgressPolicy(ctx, actorRef, precondition, mutate) +} + +func (s *ServiceImpl) DeleteEgressPolicy(ctx context.Context, actorRef resources.ActorRef) (*ateapipb.EgressPolicy, error) { + return s.store.DeleteEgressPolicy(ctx, actorRef) +} + +func validateCreateActorEgressPolicyRequest(ctx context.Context, req *ateapipb.CreateActorEgressPolicyRequest) field.ErrorList { + errs := Validate_CreateActorEgressPolicyRequest(ctx, operation.Operation{Type: operation.Create}, nil, req, nil) + errs = append(errs, validateNoUnknownFields(req.GetEgressPolicy(), field.NewPath("egress_policy"))...) + return errs +} + +func validateUpdateActorEgressPolicyRequest(ctx context.Context, req *ateapipb.UpdateActorEgressPolicyRequest) field.ErrorList { + errs := Validate_UpdateActorEgressPolicyRequest(ctx, operation.Operation{Type: operation.Create}, nil, req, nil) + errs = append(errs, validateNoUnknownFields(req.GetEgressPolicy(), field.NewPath("egress_policy"))...) + return errs +} + +func ValidateCustom_CreateActorEgressPolicyRequest(_ context.Context, _ operation.Operation, p *field.Path, req, _ *ateapipb.CreateActorEgressPolicyRequest) field.ErrorList { + return validateEgressPolicyParentAtespace(req.GetActor(), req.GetEgressPolicy(), p) +} + +func ValidateCustom_UpdateActorEgressPolicyRequest(_ context.Context, _ operation.Operation, p *field.Path, req, _ *ateapipb.UpdateActorEgressPolicyRequest) field.ErrorList { + return validateEgressPolicyParentAtespace(req.GetActor(), req.GetEgressPolicy(), p) +} + +func validateEgressPolicyParentAtespace(actor *ateapipb.ObjectRef, policy *ateapipb.EgressPolicy, p *field.Path) field.ErrorList { + if actor == nil || policy.GetMetadata() == nil || actor.GetAtespace() == "" || policy.GetMetadata().GetAtespace() == "" || actor.GetAtespace() == policy.GetMetadata().GetAtespace() { + return nil + } + return field.ErrorList{field.Invalid(p.Child("egress_policy", "metadata", "atespace"), policy.GetMetadata().GetAtespace(), "must match actor.atespace")} +} + +func ValidateCustom_EgressPolicy(_ context.Context, _ operation.Operation, root *field.Path, policy, _ *ateapipb.EgressPolicy) field.ErrorList { + var errs field.ErrorList + if name := policy.GetMetadata().GetName(); name != "" && name != "default" { + errs = append(errs, field.Invalid(root.Child("metadata", "name"), name, `must be "default"`)) + } + seenHeaders := map[string]bool{} + for i, rule := range policy.GetRules() { + rulePath := root.Child("rules").Index(i) + if rule == nil { + continue + } + seenMatches := map[string]bool{} + onlyExactHostnames := len(rule.GetAllow()) > 0 + for j, match := range rule.GetAllow() { + matchPath := rulePath.Child("allow").Index(j) + key, exactHostname := egressMatchKey(match) + onlyExactHostnames = onlyExactHostnames && exactHostname + if key != "" && seenMatches[key] { + errs = append(errs, field.Duplicate(matchPath, key)) + } + seenMatches[key] = key != "" + } + effects := rule.GetEffects() + if effects == nil { + continue + } + if (len(effects.GetInjectStaticHeader()) > 0 || effects.GetInjectActorJwt() != nil) && !onlyExactHostnames { + errs = append(errs, field.Invalid(rulePath.Child("effects"), effects, "credential-bearing effects require only exact hostname predicates")) + } + for j, injection := range effects.GetInjectStaticHeader() { + p := rulePath.Child("effects", "inject_static_header").Index(j) + if injection == nil { + continue + } + errs = append(errs, recordInjectionHeader(injection.GetHeader(), p.Child("header"), seenHeaders)...) + } + if injection := effects.GetInjectActorJwt(); injection != nil { + p := rulePath.Child("effects", "inject_actor_jwt") + errs = append(errs, recordInjectionHeader(injection.GetHeader(), p.Child("header"), seenHeaders)...) + } + } + return errs +} + +func egressMatchKey(match *ateapipb.EgressMatch) (string, bool) { + if match == nil { + return "", false + } + if match.GetAll() != nil { + return "all", false + } + if match.GetHostname() != nil { + normalized := strings.ToLower(strings.TrimSuffix(match.GetHostname().GetPattern(), ".")) + return "hostname:" + normalized, normalized != "" && !strings.HasPrefix(normalized, "*.") + } + if match.GetIpBlock() != nil { + return "ip:" + match.GetIpBlock().GetCidr(), false + } + return "", false +} + +func ValidateCustom_HostnameMatch(_ context.Context, _ operation.Operation, p *field.Path, match, _ *ateapipb.HostnameMatch) field.ErrorList { + _, _, errs := validateHostnameMatch(match, p) + return errs +} + +func ValidateCustom_IPBlockMatch(_ context.Context, _ operation.Operation, p *field.Path, match, _ *ateapipb.IPBlockMatch) field.ErrorList { + cidr := match.GetCidr() + prefix, err := netip.ParsePrefix(cidr) + if err != nil || prefix.Masked().String() != cidr { + return field.ErrorList{field.Invalid(p.Child("cidr"), cidr, "must be a canonical IPv4 or IPv6 prefix")} + } + return nil +} + +func validateHostnameMatch(match *ateapipb.HostnameMatch, p *field.Path) (string, bool, field.ErrorList) { + if match == nil { + return "", false, field.ErrorList{field.Required(p, "")} + } + raw := match.GetPattern() + normalized := strings.ToLower(strings.TrimSuffix(raw, ".")) + wildcard := strings.HasPrefix(normalized, "*.") + name := strings.TrimPrefix(normalized, "*.") + invalid := raw == "" || strings.HasSuffix(raw, "..") || (strings.Contains(normalized, "*") && !wildcard) || len(validation.IsDNS1123Subdomain(name)) != 0 + if _, err := netip.ParseAddr(name); err == nil { + invalid = true + } + if invalid { + return normalized, wildcard, field.ErrorList{field.Invalid(p.Child("pattern"), raw, "must be an exact ASCII DNS hostname or complete leftmost-label wildcard")} + } + return normalized, wildcard, nil +} + +func validateStaticHeaderInjection(injection *ateapipb.StaticHeaderInjection, p *field.Path) field.ErrorList { + if injection == nil { + return field.ErrorList{field.Required(p, "")} + } + var errs field.ErrorList + if !validHeaderName(injection.GetHeader()) { + errs = append(errs, field.Invalid(p.Child("header"), injection.GetHeader(), "must be an HTTP header name")) + } + if !validHeaderValue(injection.GetPrefix()) { + errs = append(errs, field.Invalid(p.Child("prefix"), injection.GetPrefix(), "must not contain CR, LF, or NUL")) + } + if !validCredentialURI(injection.GetCredentialUri()) { + errs = append(errs, field.Invalid(p.Child("credential_uri"), injection.GetCredentialUri(), "must be substrate-secret:////")) + } + return errs +} + +func ValidateCustom_StaticHeaderInjection(_ context.Context, _ operation.Operation, p *field.Path, injection, _ *ateapipb.StaticHeaderInjection) field.ErrorList { + return validateStaticHeaderInjection(injection, p) +} + +func validateActorTokenInjection(injection *ateapipb.ActorTokenInjection, p *field.Path) field.ErrorList { + var errs field.ErrorList + if !validHeaderName(injection.GetHeader()) { + errs = append(errs, field.Invalid(p.Child("header"), injection.GetHeader(), "must be an HTTP header name")) + } + if exchange := injection.GetRfc_8693Exchange(); exchange != nil { + u, err := url.Parse(exchange.GetUrl()) + if err != nil || u.Scheme != "https" || u.Host == "" || u.User != nil || u.Fragment != "" { + errs = append(errs, field.Invalid(p.Child("rfc_8693_exchange", "url"), exchange.GetUrl(), "must be an HTTPS URL without user information or a fragment")) + } + } + return errs +} + +func ValidateCustom_ActorTokenInjection(_ context.Context, _ operation.Operation, p *field.Path, injection, _ *ateapipb.ActorTokenInjection) field.ErrorList { + return validateActorTokenInjection(injection, p) +} + +func recordInjectionHeader(header string, p *field.Path, seen map[string]bool) field.ErrorList { + normalized := strings.ToLower(header) + if normalized == "" || !validHeaderName(normalized) { + return nil + } + if seen[normalized] { + return field.ErrorList{field.Duplicate(p, header)} + } + seen[normalized] = true + return nil +} + +func validCredentialURI(raw string) bool { + u, err := url.Parse(raw) + if err != nil || u.Scheme != "substrate-secret" || u.Host == "" || u.Host != u.Hostname() || u.User != nil || u.RawQuery != "" || u.Fragment != "" || len(validation.IsDNS1123Subdomain(u.Host)) != 0 { + return false + } + escapedPath := u.EscapedPath() + if !strings.HasPrefix(escapedPath, "/") || strings.HasSuffix(escapedPath, "/") { + return false + } + parts := strings.Split(strings.TrimPrefix(escapedPath, "/"), "/") + if len(parts) < 2 { + return false + } + for _, part := range parts { + if part == "" { + return false + } + } + return true +} + +func validHeaderName(value string) bool { + if value == "" { + return false + } + for _, c := range []byte(value) { + if !((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || strings.ContainsRune("!#$%&'*+-.^_`|~", rune(c))) { + return false + } + } + return true +} + +func validHeaderValue(value string) bool { + return !strings.ContainsAny(value, "\r\n\x00") +} + +func normalizeEgressPolicy(policy *ateapipb.EgressPolicy) *ateapipb.EgressPolicy { + result := proto.Clone(policy).(*ateapipb.EgressPolicy) + for _, rule := range result.GetRules() { + for _, match := range rule.GetAllow() { + if hostname := match.GetHostname(); hostname != nil { + hostname.Pattern = strings.ToLower(strings.TrimSuffix(hostname.GetPattern(), ".")) + } + } + for _, injection := range rule.GetEffects().GetInjectStaticHeader() { + injection.Header = strings.ToLower(injection.GetHeader()) + } + if injection := rule.GetEffects().GetInjectActorJwt(); injection != nil { + injection.Header = strings.ToLower(injection.GetHeader()) + } + } + return result +} + +func mapEgressPolicyWrite(policy *ateapipb.EgressPolicy, err error) (*ateapipb.EgressPolicy, error) { + switch { + case err == nil: + return policy, nil + case errors.Is(err, store.ErrNotFound): + return nil, status.Error(codes.NotFound, "EgressPolicy not found") + case errors.Is(err, store.ErrAlreadyExists): + return nil, status.Error(codes.AlreadyExists, "EgressPolicy already exists") + case errors.Is(err, store.ErrVersionConflict): + return nil, status.Error(codes.Aborted, "EgressPolicy version conflict") + case errors.Is(err, store.ErrUIDConflict): + return nil, status.Error(codes.Aborted, "EgressPolicy UID conflict") + case errors.Is(err, store.ErrPreconditionRequired): + return nil, status.Error(codes.InvalidArgument, "EgressPolicy UID and version are required") + case errors.Is(err, store.ErrFailedPrecondition): + return nil, status.Error(codes.FailedPrecondition, "parent Actor does not exist") + default: + return nil, fmt.Errorf("while writing EgressPolicy: %w", err) + } +} diff --git a/cmd/ateapi/internal/controlapi/egress_policy_test.go b/cmd/ateapi/internal/controlapi/egress_policy_test.go new file mode 100644 index 000000000..9233e6084 --- /dev/null +++ b/cmd/ateapi/internal/controlapi/egress_policy_test.go @@ -0,0 +1,238 @@ +// 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" + "testing" + + "github.com/agent-substrate/substrate/cmd/ateapi/internal/store/storetest" + "github.com/agent-substrate/substrate/pkg/proto/ateapipb" + "google.golang.org/grpc/codes" + "google.golang.org/grpc/status" + "google.golang.org/protobuf/proto" + "google.golang.org/protobuf/types/known/emptypb" + "k8s.io/apimachinery/pkg/util/validation/field" +) + +func validEgressPolicy() *ateapipb.EgressPolicy { + return &ateapipb.EgressPolicy{ + Metadata: &ateapipb.ResourceMetadata{Atespace: testAtespace, Name: "default"}, + Rules: []*ateapipb.EgressRule{{ + Allow: []*ateapipb.EgressMatch{{Hostname: &ateapipb.HostnameMatch{Pattern: "api.example.com"}}}, + Effects: &ateapipb.EgressRuleEffects{InjectStaticHeader: []*ateapipb.StaticHeaderInjection{{ + Header: "Authorization", Prefix: "Bearer ", CredentialUri: "substrate-secret://kubernetes.io/provider/ns/name", + }}}, + }}} +} + +func TestValidateCreateActorEgressPolicyRequest(t *testing.T) { + validReq := func() *ateapipb.CreateActorEgressPolicyRequest { + return &ateapipb.CreateActorEgressPolicyRequest{ + Actor: &ateapipb.ObjectRef{Atespace: testAtespace, Name: "actor"}, + EgressPolicy: validEgressPolicy(), + } + } + + tests := []struct { + name string + req *ateapipb.CreateActorEgressPolicyRequest + want field.ErrorList + }{ + {name: "valid", req: validReq()}, + {name: "missing actor", req: func() *ateapipb.CreateActorEgressPolicyRequest { r := validReq(); r.Actor = nil; return r }(), want: field.ErrorList{field.Required(field.NewPath("actor"), "")}}, + {name: "missing actor atespace", req: func() *ateapipb.CreateActorEgressPolicyRequest { r := validReq(); r.Actor.Atespace = ""; return r }(), want: field.ErrorList{field.Required(field.NewPath("actor", "atespace"), "")}}, + {name: "missing policy", req: func() *ateapipb.CreateActorEgressPolicyRequest { r := validReq(); r.EgressPolicy = nil; return r }(), want: field.ErrorList{field.Required(field.NewPath("egress_policy"), "")}}, + {name: "missing metadata", req: func() *ateapipb.CreateActorEgressPolicyRequest { + r := validReq() + r.EgressPolicy.Metadata = nil + return r + }(), want: field.ErrorList{field.Required(field.NewPath("egress_policy", "metadata"), "")}}, + {name: "missing policy atespace", req: func() *ateapipb.CreateActorEgressPolicyRequest { + r := validReq() + r.EgressPolicy.Metadata.Atespace = "" + return r + }(), want: field.ErrorList{field.Required(field.NewPath("egress_policy", "metadata", "atespace"), "")}}, + {name: "missing default name", req: func() *ateapipb.CreateActorEgressPolicyRequest { + r := validReq() + r.EgressPolicy.Metadata.Name = "" + return r + }(), want: field.ErrorList{field.Required(field.NewPath("egress_policy", "metadata", "name"), "")}}, + {name: "wrong policy name", req: func() *ateapipb.CreateActorEgressPolicyRequest { + r := validReq() + r.EgressPolicy.Metadata.Name = "other" + return r + }(), want: field.ErrorList{field.Invalid(field.NewPath("egress_policy", "metadata", "name"), "other", `must be "default"`)}}, + {name: "mismatched policy atespace", req: func() *ateapipb.CreateActorEgressPolicyRequest { + r := validReq() + r.EgressPolicy.Metadata.Atespace = "other" + return r + }(), want: field.ErrorList{field.Invalid(field.NewPath("egress_policy", "metadata", "atespace"), "other", "must match actor.atespace")}}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + assertValidateErr(t, validateCreateActorEgressPolicyRequest(context.Background(), tc.req), tc.want) + }) + } +} + +func TestValidateEgressPolicyRules(t *testing.T) { + tests := []struct { + name string + mutate func(*ateapipb.EgressPolicy) + }{ + {name: "empty allow", mutate: func(p *ateapipb.EgressPolicy) { p.Rules[0].Allow = nil }}, + {name: "multiple predicates", mutate: func(p *ateapipb.EgressPolicy) { p.Rules[0].Allow[0].All = &emptypb.Empty{} }}, + {name: "wildcard credential effect", mutate: func(p *ateapipb.EgressPolicy) { p.Rules[0].Allow[0].GetHostname().Pattern = "*.example.com" }}, + {name: "noncanonical CIDR", mutate: func(p *ateapipb.EgressPolicy) { + p.Rules[0].Allow[0] = &ateapipb.EgressMatch{IpBlock: &ateapipb.IPBlockMatch{Cidr: "192.0.2.1/24"}} + }}, + {name: "invalid credential URI", mutate: func(p *ateapipb.EgressPolicy) { + p.Rules[0].Effects.InjectStaticHeader[0].CredentialUri = "https://example.com/secret" + }}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + req := &ateapipb.CreateActorEgressPolicyRequest{Actor: &ateapipb.ObjectRef{Atespace: testAtespace, Name: "actor"}, EgressPolicy: validEgressPolicy()} + tc.mutate(req.EgressPolicy) + if errs := validateCreateActorEgressPolicyRequest(context.Background(), req); len(errs) == 0 { + t.Fatal("invalid policy accepted") + } + }) + } +} + +func TestActorEgressPolicy(t *testing.T) { + persistence, cleanup := storetest.SetupTestStore(t) + defer cleanup() + service := &RPCService{impl: &ServiceImpl{store: persistence}} + if _, err := persistence.CreateAtespace(t.Context(), &ateapipb.Atespace{Metadata: &ateapipb.ResourceMetadata{Name: testAtespace}}); err != nil { + t.Fatal(err) + } + _, err := persistence.CreateActor(t.Context(), &ateapipb.Actor{ + Metadata: &ateapipb.ResourceMetadata{Atespace: testAtespace, Name: "egress-actor"}, + Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_RUNNING}, + }) + if err != nil { + t.Fatal(err) + } + actorRef := &ateapipb.ObjectRef{Atespace: testAtespace, Name: "egress-actor"} + + if _, err := service.GetActorEgressPolicy(t.Context(), &ateapipb.GetActorEgressPolicyRequest{Actor: actorRef}); status.Code(err) != codes.NotFound { + t.Fatalf("policy before create status = %v, want NotFound", status.Code(err)) + } + if _, err := service.GetActorEgressPolicy(t.Context(), &ateapipb.GetActorEgressPolicyRequest{ + Actor: &ateapipb.ObjectRef{Atespace: testAtespace, Name: "missing-actor"}, + }); status.Code(err) != codes.NotFound { + t.Fatalf("missing parent status = %v, want NotFound", status.Code(err)) + } + created, err := service.CreateActorEgressPolicy(t.Context(), &ateapipb.CreateActorEgressPolicyRequest{ + Actor: actorRef, + EgressPolicy: &ateapipb.EgressPolicy{Metadata: &ateapipb.ResourceMetadata{Atespace: testAtespace, Name: "default", Uid: "ignored", Version: 99}, Rules: []*ateapipb.EgressRule{{ + Allow: []*ateapipb.EgressMatch{{Hostname: &ateapipb.HostnameMatch{Pattern: "API.EXAMPLE.COM."}}}, + Effects: &ateapipb.EgressRuleEffects{InjectStaticHeader: []*ateapipb.StaticHeaderInjection{{ + Header: "Authorization", Prefix: "Bearer ", CredentialUri: "substrate-secret://kubernetes.io/provider/ns/name", + }}}, + }}}, + }) + if err != nil { + t.Fatal(err) + } + if _, err := service.CreateActorEgressPolicy(t.Context(), &ateapipb.CreateActorEgressPolicyRequest{ + Actor: actorRef, EgressPolicy: &ateapipb.EgressPolicy{Metadata: &ateapipb.ResourceMetadata{Atespace: testAtespace, Name: "default"}}, + }); status.Code(err) != codes.AlreadyExists { + t.Fatalf("create collision status = %v, want AlreadyExists", status.Code(err)) + } + if created.GetRules()[0].GetAllow()[0].GetHostname().GetPattern() != "api.example.com" || created.GetRules()[0].GetEffects().GetInjectStaticHeader()[0].GetHeader() != "authorization" { + t.Fatalf("policy was not normalized: %v", created) + } + if md := created.GetMetadata(); md.GetName() != "default" || md.GetAtespace() != testAtespace || md.GetUid() == "" || md.GetVersion() != 1 || md.GetCreateTime() == nil || md.GetUpdateTime() == nil { + t.Fatalf("created metadata = %v", md) + } + got, err := service.GetActorEgressPolicy(t.Context(), &ateapipb.GetActorEgressPolicyRequest{Actor: actorRef}) + if err != nil || !proto.Equal(got, created) { + t.Fatalf("policy after create = %v, %v; want %v", got, err, created) + } + replacement := proto.Clone(created).(*ateapipb.EgressPolicy) + replacement.Rules = nil + missingPreconditions := proto.Clone(replacement).(*ateapipb.EgressPolicy) + missingPreconditions.Metadata.Uid = "" + missingPreconditions.Metadata.Version = 0 + if _, err := service.UpdateActorEgressPolicy(t.Context(), &ateapipb.UpdateActorEgressPolicyRequest{Actor: actorRef, EgressPolicy: missingPreconditions}); status.Code(err) != codes.InvalidArgument { + t.Fatalf("missing preconditions status = %v, want InvalidArgument", status.Code(err)) + } + changedIdentity := proto.Clone(replacement).(*ateapipb.EgressPolicy) + changedIdentity.Metadata.Atespace = "other" + changedIdentity.Metadata.Name = "other" + if _, err := service.UpdateActorEgressPolicy(t.Context(), &ateapipb.UpdateActorEgressPolicyRequest{Actor: actorRef, EgressPolicy: changedIdentity}); status.Code(err) != codes.InvalidArgument { + t.Fatalf("changed identity status = %v, want InvalidArgument", status.Code(err)) + } + unknown := proto.Clone(replacement).(*ateapipb.EgressPolicy) + unknown.ProtoReflect().SetUnknown(unknownField(9999)) + if _, err := service.UpdateActorEgressPolicy(t.Context(), &ateapipb.UpdateActorEgressPolicyRequest{Actor: actorRef, EgressPolicy: unknown}); status.Code(err) != codes.InvalidArgument { + t.Fatalf("unknown field status = %v, want InvalidArgument", status.Code(err)) + } + updated, err := service.UpdateActorEgressPolicy(t.Context(), &ateapipb.UpdateActorEgressPolicyRequest{Actor: actorRef, EgressPolicy: replacement}) + if err != nil || updated.GetMetadata().GetVersion() != 2 || len(updated.GetRules()) != 0 { + t.Fatalf("replacement = %v, %v; want empty version 2", updated, err) + } + if _, err := service.UpdateActorEgressPolicy(t.Context(), &ateapipb.UpdateActorEgressPolicyRequest{ + Actor: actorRef, EgressPolicy: replacement, + }); status.Code(err) != codes.Aborted { + t.Fatalf("stale replacement status = %v, want Aborted", status.Code(err)) + } + deleted, err := service.DeleteActorEgressPolicy(t.Context(), &ateapipb.DeleteActorEgressPolicyRequest{Actor: actorRef}) + if err != nil || !proto.Equal(deleted, updated) { + t.Fatalf("deleted policy = %v, %v; want %v", deleted, err, updated) + } + if _, err := service.GetActorEgressPolicy(t.Context(), &ateapipb.GetActorEgressPolicyRequest{Actor: actorRef}); status.Code(err) != codes.NotFound { + t.Fatalf("policy after delete status = %v, want NotFound", status.Code(err)) + } +} + +func TestCredentialURIValidation(t *testing.T) { + for _, uri := range []string{ + "substrate-secret://kubernetes.io/provider/ns/name", + "substrate-secret://vault.example/provider/secret", + } { + if !validCredentialURI(uri) { + t.Errorf("validCredentialURI(%q) = false", uri) + } + } + for _, uri := range []string{ + "https://kubernetes.io/provider/ns/name", + "substrate-secret://kubernetes.io/provider", + "substrate-secret://kubernetes.io//provider/secret", + "substrate-secret://kubernetes.io/provider/secret/", + "substrate-secret://kubernetes.io:443/provider/secret", + } { + if validCredentialURI(uri) { + t.Errorf("validCredentialURI(%q) = true", uri) + } + } +} + +func TestHeaderValueValidation(t *testing.T) { + for _, value := range []string{"Bearer token", "\u0080\u0081"} { + if !validHeaderValue(value) { + t.Errorf("validHeaderValue(%q) = false", value) + } + } + for _, value := range []string{"a\rb", "a\nb", "a\x00b"} { + if validHeaderValue(value) { + t.Errorf("validHeaderValue(%q) = true", value) + } + } +} diff --git a/cmd/ateapi/internal/controlapi/service.go b/cmd/ateapi/internal/controlapi/service.go index 6b61e13f9..5c3af8e0f 100644 --- a/cmd/ateapi/internal/controlapi/service.go +++ b/cmd/ateapi/internal/controlapi/service.go @@ -91,6 +91,10 @@ type serviceStore interface { 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) + CreateEgressPolicy(ctx context.Context, actorRef resources.ActorRef, policy *ateapipb.EgressPolicy) (*ateapipb.EgressPolicy, error) + GetEgressPolicy(ctx context.Context, actorRef resources.ActorRef) (*ateapipb.EgressPolicy, error) + UpdateEgressPolicy(ctx context.Context, actorRef resources.ActorRef, precondition store.Precondition, mutate func(*ateapipb.EgressPolicy) error) (*ateapipb.EgressPolicy, error) + DeleteEgressPolicy(ctx context.Context, actorRef resources.ActorRef) (*ateapipb.EgressPolicy, error) GetActorSnapshot(ctx context.Context, snapshotRef resources.ActorSnapshotRef) (*ateapipb.ActorSnapshot, error) ListActorSnapshots(ctx context.Context, atespace string, opts store.ListOptions) (store.ListResponse[*ateapipb.ActorSnapshot], error) CreateActorSnapshotTag(ctx context.Context, snapshotRef resources.ActorSnapshotRef, tag *ateapipb.ActorSnapshotTag) (*ateapipb.ActorSnapshotTag, error) diff --git a/cmd/ateapi/internal/controlapi/zz_generated.validation.go b/cmd/ateapi/internal/controlapi/zz_generated.validation.go index e09b0c846..5b8640c1c 100644 --- a/cmd/ateapi/internal/controlapi/zz_generated.validation.go +++ b/cmd/ateapi/internal/controlapi/zz_generated.validation.go @@ -23,6 +23,7 @@ import ( context "context" ateapipb "github.com/agent-substrate/substrate/pkg/proto/ateapipb" + emptypb "google.golang.org/protobuf/types/known/emptypb" timestamppb "google.golang.org/protobuf/types/known/timestamppb" operation "k8s.io/apimachinery/pkg/api/operation" safe "k8s.io/apimachinery/pkg/api/safe" @@ -404,6 +405,51 @@ func Validate_ActorStatus( return errs } +// Validate_ActorTokenInjection validates an instance of ActorTokenInjection according +// to declarative validation rules in the API schema. +func Validate_ActorTokenInjection( + ctx context.Context, op operation.Operation, fldPath *field.Path, + obj, oldObj *ateapipb.ActorTokenInjection) (errs field.ErrorList) { + + // custom validation + if e := ValidateCustom_ActorTokenInjection(ctx, op, fldPath, obj, oldObj); len(e) != 0 { + errs = append(errs, e...) + } + + { // field ateapipb.ActorTokenInjection.Header + fn := func( + fldPath *field.Path, + obj, oldObj *string, + oldValueCorrelated bool) (errs field.ErrorList) { + // don't revalidate unchanged data + if oldValueCorrelated && op.Type == operation.Update { + if obj == oldObj || (obj != nil && oldObj != nil && *obj == *oldObj) { + return nil + } + } + // call field-attached validations + earlyReturn := false + if e := validate.RequiredValue(ctx, op, fldPath, obj, oldObj).MarkShortCircuit(); len(e) != 0 { + errs = append(errs, e...) + earlyReturn = true + } + if earlyReturn { + return // do not proceed + } + return + } + oldVal := safe.Field(oldObj, + func(oldObj *ateapipb.ActorTokenInjection) *string { + return &oldObj.Header + }) + errs = append(errs, fn(fldPath.Child("header"), &obj.Header, oldVal, oldObj != nil)...) + } + + // field ateapipb.ActorTokenInjection.Audiences has no validation + // field ateapipb.ActorTokenInjection.Rfc_8693Exchange has no validation + return errs +} + // Validate_Atespace validates an instance of Atespace according // to declarative validation rules in the API schema. func Validate_Atespace( @@ -467,16 +513,598 @@ func Validate_Atespace( return errs } -// Validate_CreateActorRequest validates an instance of CreateActorRequest according +// Validate_CreateActorEgressPolicyRequest validates an instance of CreateActorEgressPolicyRequest according +// to declarative validation rules in the API schema. +func Validate_CreateActorEgressPolicyRequest( + ctx context.Context, op operation.Operation, fldPath *field.Path, + obj, oldObj *ateapipb.CreateActorEgressPolicyRequest) (errs field.ErrorList) { + + // custom validation + if e := ValidateCustom_CreateActorEgressPolicyRequest(ctx, op, fldPath, obj, oldObj); len(e) != 0 { + errs = append(errs, e...) + } + + { // field ateapipb.CreateActorEgressPolicyRequest.Actor + fn := func( + fldPath *field.Path, + obj, oldObj *ateapipb.ObjectRef, + 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.RequiredPointer(ctx, op, fldPath, obj, oldObj).MarkShortCircuit(); len(e) != 0 { + errs = append(errs, e...) + earlyReturn = true + } + if earlyReturn { + return // do not proceed + } + func() { // cohort = "atespace" + earlyReturn := false + if e := validate.Subfield(ctx, op, fldPath, obj, oldObj, "atespace", + func(o *ateapipb.ObjectRef) *string { return &o.Atespace }, validate.DirectEqual, validate.RequiredValue).MarkShortCircuit(); len(e) != 0 { + errs = append(errs, e...) + earlyReturn = true + } + if e := validate.Subfield(ctx, op, fldPath, obj, oldObj, "atespace", + func(o *ateapipb.ObjectRef) *string { return &o.Atespace }, validate.DirectEqual, validate.OptionalValue).MarkShortCircuit(); len(e) != 0 { + earlyReturn = true + } + if earlyReturn { + return // do not proceed + } + }() + // call the type's validation function + errs = append(errs, Validate_ObjectRef(ctx, op, fldPath, obj, oldObj)...) + return + } + oldVal := safe.Field(oldObj, + func(oldObj *ateapipb.CreateActorEgressPolicyRequest) *ateapipb.ObjectRef { + return oldObj.Actor + }) + errs = append(errs, fn(fldPath.Child("actor"), obj.Actor, oldVal, oldObj != nil)...) + } + + { // field ateapipb.CreateActorEgressPolicyRequest.EgressPolicy + 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.RequiredPointer(ctx, op, fldPath, obj, oldObj).MarkShortCircuit(); len(e) != 0 { + errs = append(errs, e...) + 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.CreateActorEgressPolicyRequest) *ateapipb.EgressPolicy { + return oldObj.EgressPolicy + }) + errs = append(errs, fn(fldPath.Child("egress_policy"), obj.EgressPolicy, oldVal, oldObj != nil)...) + } + + return errs +} + +// Validate_CreateActorRequest validates an instance of CreateActorRequest according +// to declarative validation rules in the API schema. +func Validate_CreateActorRequest( + ctx context.Context, op operation.Operation, fldPath *field.Path, + obj, oldObj *ateapipb.CreateActorRequest) (errs field.ErrorList) { + + { // field ateapipb.CreateActorRequest.Actor + fn := func( + fldPath *field.Path, + obj, oldObj *ateapipb.Actor, + 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.RequiredPointer(ctx, op, fldPath, obj, oldObj).MarkShortCircuit(); len(e) != 0 { + errs = append(errs, e...) + earlyReturn = true + } + if earlyReturn { + return // do not proceed + } + // call the type's validation function + errs = append(errs, Validate_Actor(ctx, op, fldPath, obj, oldObj)...) + return + } + oldVal := safe.Field(oldObj, + func(oldObj *ateapipb.CreateActorRequest) *ateapipb.Actor { + return oldObj.Actor + }) + errs = append(errs, fn(fldPath.Child("actor"), obj.Actor, oldVal, oldObj != nil)...) + } + + return errs +} + +// Validate_CreateAtespaceRequest validates an instance of CreateAtespaceRequest according +// to declarative validation rules in the API schema. +func Validate_CreateAtespaceRequest( + ctx context.Context, op operation.Operation, fldPath *field.Path, + obj, oldObj *ateapipb.CreateAtespaceRequest) (errs field.ErrorList) { + + { // field ateapipb.CreateAtespaceRequest.Atespace + fn := func( + fldPath *field.Path, + obj, oldObj *ateapipb.Atespace, + 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.RequiredPointer(ctx, op, fldPath, obj, oldObj).MarkShortCircuit(); len(e) != 0 { + errs = append(errs, e...) + earlyReturn = true + } + if earlyReturn { + return // do not proceed + } + // call the type's validation function + errs = append(errs, Validate_Atespace(ctx, op, fldPath, obj, oldObj)...) + return + } + oldVal := safe.Field(oldObj, + func(oldObj *ateapipb.CreateAtespaceRequest) *ateapipb.Atespace { + return oldObj.Atespace + }) + errs = append(errs, fn(fldPath.Child("atespace"), obj.Atespace, oldVal, oldObj != nil)...) + } + + return errs +} + +// Validate_DeleteActorEgressPolicyRequest validates an instance of DeleteActorEgressPolicyRequest according +// to declarative validation rules in the API schema. +func Validate_DeleteActorEgressPolicyRequest( + ctx context.Context, op operation.Operation, fldPath *field.Path, + obj, oldObj *ateapipb.DeleteActorEgressPolicyRequest) (errs field.ErrorList) { + + { // field ateapipb.DeleteActorEgressPolicyRequest.Actor + fn := func( + fldPath *field.Path, + obj, oldObj *ateapipb.ObjectRef, + 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.RequiredPointer(ctx, op, fldPath, obj, oldObj).MarkShortCircuit(); len(e) != 0 { + errs = append(errs, e...) + earlyReturn = true + } + if earlyReturn { + return // do not proceed + } + func() { // cohort = "atespace" + earlyReturn := false + if e := validate.Subfield(ctx, op, fldPath, obj, oldObj, "atespace", + func(o *ateapipb.ObjectRef) *string { return &o.Atespace }, validate.DirectEqual, validate.RequiredValue).MarkShortCircuit(); len(e) != 0 { + errs = append(errs, e...) + earlyReturn = true + } + if e := validate.Subfield(ctx, op, fldPath, obj, oldObj, "atespace", + func(o *ateapipb.ObjectRef) *string { return &o.Atespace }, validate.DirectEqual, validate.OptionalValue).MarkShortCircuit(); len(e) != 0 { + earlyReturn = true + } + if earlyReturn { + return // do not proceed + } + }() + // call the type's validation function + errs = append(errs, Validate_ObjectRef(ctx, op, fldPath, obj, oldObj)...) + return + } + oldVal := safe.Field(oldObj, + func(oldObj *ateapipb.DeleteActorEgressPolicyRequest) *ateapipb.ObjectRef { + return oldObj.Actor + }) + errs = append(errs, fn(fldPath.Child("actor"), obj.Actor, oldVal, oldObj != nil)...) + } + + return errs +} + +// Validate_DeleteAtespaceRequest validates an instance of DeleteAtespaceRequest according +// to declarative validation rules in the API schema. +func Validate_DeleteAtespaceRequest( + ctx context.Context, op operation.Operation, fldPath *field.Path, + obj, oldObj *ateapipb.DeleteAtespaceRequest) (errs field.ErrorList) { + + { // field ateapipb.DeleteAtespaceRequest.Atespace + fn := func( + fldPath *field.Path, + obj, oldObj *ateapipb.ObjectRef, + 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.RequiredPointer(ctx, op, fldPath, obj, oldObj).MarkShortCircuit(); len(e) != 0 { + errs = append(errs, e...) + earlyReturn = true + } + if earlyReturn { + return // do not proceed + } + func() { // cohort = "atespace" + earlyReturn := false + if e := validate.Subfield(ctx, op, fldPath, obj, oldObj, "atespace", + func(o *ateapipb.ObjectRef) *string { return &o.Atespace }, validate.DirectEqual, validate.ForbiddenValue).MarkBeta().MarkShortCircuit(); len(e) != 0 { + errs = append(errs, e...) + earlyReturn = true + } + if e := validate.Subfield(ctx, op, fldPath, obj, oldObj, "atespace", + func(o *ateapipb.ObjectRef) *string { return &o.Atespace }, validate.DirectEqual, validate.OptionalValue).MarkBeta().MarkShortCircuit(); len(e) != 0 { + earlyReturn = true + } + if e := validate.Subfield(ctx, op, fldPath, obj, oldObj, "atespace", + func(o *ateapipb.ObjectRef) *string { return &o.Atespace }, validate.DirectEqual, validate.OptionalValue).MarkBeta().MarkShortCircuit(); len(e) != 0 { + earlyReturn = true + } + if earlyReturn { + return // do not proceed + } + }() + // call the type's validation function + errs = append(errs, Validate_ObjectRef(ctx, op, fldPath, obj, oldObj)...) + return + } + oldVal := safe.Field(oldObj, + func(oldObj *ateapipb.DeleteAtespaceRequest) *ateapipb.ObjectRef { + return oldObj.Atespace + }) + errs = append(errs, fn(fldPath.Child("atespace"), obj.Atespace, oldVal, oldObj != nil)...) + } + + return errs +} + +var unionMembershipFor_github_com_agent_substrate_substrate_pkg_proto_ateapipb_EgressMatch_ = validate.NewUnionMembership(validate.NewUnionMember("all"), validate.NewUnionMember("hostname"), validate.NewUnionMember("ip_block")) + +// Validate_EgressMatch validates an instance of EgressMatch according +// to declarative validation rules in the API schema. +func Validate_EgressMatch( + ctx context.Context, op operation.Operation, fldPath *field.Path, + obj, oldObj *ateapipb.EgressMatch) (errs field.ErrorList) { + + if e := validate.Union(ctx, op, fldPath, obj, oldObj, unionMembershipFor_github_com_agent_substrate_substrate_pkg_proto_ateapipb_EgressMatch_, + func(obj *ateapipb.EgressMatch) bool { + if obj == nil { + return false + } + return obj.All != nil + }, + func(obj *ateapipb.EgressMatch) bool { + if obj == nil { + return false + } + return obj.Hostname != nil + }, + func(obj *ateapipb.EgressMatch) bool { + if obj == nil { + return false + } + return obj.IpBlock != nil + }); len(e) != 0 { + errs = append(errs, e...) + } + + { // field ateapipb.EgressMatch.All + fn := func( + fldPath *field.Path, + obj, oldObj *emptypb.Empty, + 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 + } + return + } + oldVal := safe.Field(oldObj, + func(oldObj *ateapipb.EgressMatch) *emptypb.Empty { + return oldObj.All + }) + errs = append(errs, fn(fldPath.Child("all"), obj.All, oldVal, oldObj != nil)...) + } + + { // field ateapipb.EgressMatch.Hostname + fn := func( + fldPath *field.Path, + obj, oldObj *ateapipb.HostnameMatch, + 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_HostnameMatch(ctx, op, fldPath, obj, oldObj)...) + return + } + oldVal := safe.Field(oldObj, + func(oldObj *ateapipb.EgressMatch) *ateapipb.HostnameMatch { + return oldObj.Hostname + }) + errs = append(errs, fn(fldPath.Child("hostname"), obj.Hostname, oldVal, oldObj != nil)...) + } + + { // field ateapipb.EgressMatch.IpBlock + fn := func( + fldPath *field.Path, + obj, oldObj *ateapipb.IPBlockMatch, + 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_IPBlockMatch(ctx, op, fldPath, obj, oldObj)...) + return + } + oldVal := safe.Field(oldObj, + func(oldObj *ateapipb.EgressMatch) *ateapipb.IPBlockMatch { + return oldObj.IpBlock + }) + errs = append(errs, fn(fldPath.Child("ip_block"), obj.IpBlock, oldVal, oldObj != nil)...) + } + + return errs +} + +// Validate_EgressPolicy validates an instance of EgressPolicy according +// to declarative validation rules in the API schema. +func Validate_EgressPolicy( + ctx context.Context, op operation.Operation, fldPath *field.Path, + obj, oldObj *ateapipb.EgressPolicy) (errs field.ErrorList) { + + // custom validation + if e := ValidateCustom_EgressPolicy(ctx, op, fldPath, obj, oldObj); len(e) != 0 { + errs = append(errs, e...) + } + + { // field ateapipb.EgressPolicy.Metadata + fn := func( + fldPath *field.Path, + obj, oldObj *ateapipb.ResourceMetadata, + 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.RequiredPointer(ctx, op, fldPath, obj, oldObj).MarkShortCircuit(); len(e) != 0 { + errs = append(errs, e...) + earlyReturn = true + } + if earlyReturn { + return // do not proceed + } + func() { // cohort = "atespace" + earlyReturn := false + if e := validate.Subfield(ctx, op, fldPath, obj, oldObj, "atespace", + func(o *ateapipb.ResourceMetadata) *string { return &o.Atespace }, validate.DirectEqual, validate.RequiredValue).MarkShortCircuit(); len(e) != 0 { + errs = append(errs, e...) + earlyReturn = true + } + if e := validate.Subfield(ctx, op, fldPath, obj, oldObj, "atespace", + func(o *ateapipb.ResourceMetadata) *string { return &o.Atespace }, validate.DirectEqual, validate.Immutable).MarkShortCircuit(); len(e) != 0 { + earlyReturn = true + } + if e := validate.Subfield(ctx, op, fldPath, obj, oldObj, "atespace", + func(o *ateapipb.ResourceMetadata) *string { return &o.Atespace }, validate.DirectEqual, validate.OptionalValue).MarkShortCircuit(); len(e) != 0 { + earlyReturn = true + } + if earlyReturn { + return // do not proceed + } + }() + // call the type's validation function + errs = append(errs, Validate_ResourceMetadata(ctx, op, fldPath, obj, oldObj)...) + return + } + oldVal := safe.Field(oldObj, + func(oldObj *ateapipb.EgressPolicy) *ateapipb.ResourceMetadata { + return oldObj.Metadata + }) + errs = append(errs, fn(fldPath.Child("metadata"), obj.Metadata, oldVal, oldObj != nil)...) + } + + { // field ateapipb.EgressPolicy.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.OptionalSlice(ctx, op, fldPath, obj, oldObj).MarkShortCircuit(); len(e) != 0 { + earlyReturn = true + } + if earlyReturn { + return // do not proceed + } + // 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.EgressPolicy) []*ateapipb.EgressRule { + return oldObj.Rules + }) + errs = append(errs, fn(fldPath.Child("rules"), obj.Rules, oldVal, oldObj != nil)...) + } + + return errs +} + +// Validate_EgressRule validates an instance of EgressRule according +// to declarative validation rules in the API schema. +func Validate_EgressRule( + ctx context.Context, op operation.Operation, fldPath *field.Path, + obj, oldObj *ateapipb.EgressRule) (errs field.ErrorList) { + + { // field ateapipb.EgressRule.Allow + fn := func( + fldPath *field.Path, + obj, oldObj []*ateapipb.EgressMatch, + 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.EgressMatch](ctx, op, fldPath, obj, oldObj).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 + } + // iterate the list and call the type's validation function + if e := validate.EachPtrSliceVal(ctx, op, fldPath, obj, oldObj, nil, nil, Validate_EgressMatch); len(e) != 0 { + errs = append(errs, e...) + } + return + } + oldVal := safe.Field(oldObj, + func(oldObj *ateapipb.EgressRule) []*ateapipb.EgressMatch { + return oldObj.Allow + }) + errs = append(errs, fn(fldPath.Child("allow"), obj.Allow, oldVal, oldObj != nil)...) + } + + { // field ateapipb.EgressRule.Effects + fn := func( + fldPath *field.Path, + obj, oldObj *ateapipb.EgressRuleEffects, + 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_EgressRuleEffects(ctx, op, fldPath, obj, oldObj)...) + return + } + oldVal := safe.Field(oldObj, + func(oldObj *ateapipb.EgressRule) *ateapipb.EgressRuleEffects { + return oldObj.Effects + }) + errs = append(errs, fn(fldPath.Child("effects"), obj.Effects, oldVal, oldObj != nil)...) + } + + return errs +} + +// Validate_EgressRuleEffects validates an instance of EgressRuleEffects according // to declarative validation rules in the API schema. -func Validate_CreateActorRequest( +func Validate_EgressRuleEffects( ctx context.Context, op operation.Operation, fldPath *field.Path, - obj, oldObj *ateapipb.CreateActorRequest) (errs field.ErrorList) { + obj, oldObj *ateapipb.EgressRuleEffects) (errs field.ErrorList) { - { // field ateapipb.CreateActorRequest.Actor + { // field ateapipb.EgressRuleEffects.InjectStaticHeader fn := func( fldPath *field.Path, - obj, oldObj *ateapipb.Actor, + obj, oldObj []*ateapipb.StaticHeaderInjection, oldValueCorrelated bool) (errs field.ErrorList) { // don't revalidate unchanged data if oldValueCorrelated && op.Type == operation.Update { @@ -486,37 +1114,33 @@ func Validate_CreateActorRequest( } // call field-attached validations earlyReturn := false - if e := validate.RequiredPointer(ctx, op, fldPath, obj, oldObj).MarkShortCircuit(); len(e) != 0 { + if e := validate.PtrSliceNoNils[ateapipb.StaticHeaderInjection](ctx, op, fldPath, obj, oldObj).MarkShortCircuit(); len(e) != 0 { errs = append(errs, e...) earlyReturn = true } + if e := validate.OptionalSlice(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_Actor(ctx, op, fldPath, obj, oldObj)...) + // iterate the list and call the type's validation function + if e := validate.EachPtrSliceVal(ctx, op, fldPath, obj, oldObj, nil, nil, Validate_StaticHeaderInjection); len(e) != 0 { + errs = append(errs, e...) + } return } oldVal := safe.Field(oldObj, - func(oldObj *ateapipb.CreateActorRequest) *ateapipb.Actor { - return oldObj.Actor + func(oldObj *ateapipb.EgressRuleEffects) []*ateapipb.StaticHeaderInjection { + return oldObj.InjectStaticHeader }) - errs = append(errs, fn(fldPath.Child("actor"), obj.Actor, oldVal, oldObj != nil)...) + errs = append(errs, fn(fldPath.Child("inject_static_header"), obj.InjectStaticHeader, oldVal, oldObj != nil)...) } - return errs -} - -// Validate_CreateAtespaceRequest validates an instance of CreateAtespaceRequest according -// to declarative validation rules in the API schema. -func Validate_CreateAtespaceRequest( - ctx context.Context, op operation.Operation, fldPath *field.Path, - obj, oldObj *ateapipb.CreateAtespaceRequest) (errs field.ErrorList) { - - { // field ateapipb.CreateAtespaceRequest.Atespace + { // field ateapipb.EgressRuleEffects.InjectActorJwt fn := func( fldPath *field.Path, - obj, oldObj *ateapipb.Atespace, + obj, oldObj *ateapipb.ActorTokenInjection, oldValueCorrelated bool) (errs field.ErrorList) { // don't revalidate unchanged data if oldValueCorrelated && op.Type == operation.Update { @@ -526,34 +1150,33 @@ func Validate_CreateAtespaceRequest( } // call field-attached validations earlyReturn := false - if e := validate.RequiredPointer(ctx, op, fldPath, obj, oldObj).MarkShortCircuit(); len(e) != 0 { - errs = append(errs, e...) + 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_Atespace(ctx, op, fldPath, obj, oldObj)...) + errs = append(errs, Validate_ActorTokenInjection(ctx, op, fldPath, obj, oldObj)...) return } oldVal := safe.Field(oldObj, - func(oldObj *ateapipb.CreateAtespaceRequest) *ateapipb.Atespace { - return oldObj.Atespace + func(oldObj *ateapipb.EgressRuleEffects) *ateapipb.ActorTokenInjection { + return oldObj.InjectActorJwt }) - errs = append(errs, fn(fldPath.Child("atespace"), obj.Atespace, oldVal, oldObj != nil)...) + errs = append(errs, fn(fldPath.Child("inject_actor_jwt"), obj.InjectActorJwt, oldVal, oldObj != nil)...) } return errs } -// Validate_DeleteAtespaceRequest validates an instance of DeleteAtespaceRequest according +// Validate_GetActorEgressPolicyRequest validates an instance of GetActorEgressPolicyRequest according // to declarative validation rules in the API schema. -func Validate_DeleteAtespaceRequest( +func Validate_GetActorEgressPolicyRequest( ctx context.Context, op operation.Operation, fldPath *field.Path, - obj, oldObj *ateapipb.DeleteAtespaceRequest) (errs field.ErrorList) { + obj, oldObj *ateapipb.GetActorEgressPolicyRequest) (errs field.ErrorList) { - { // field ateapipb.DeleteAtespaceRequest.Atespace + { // field ateapipb.GetActorEgressPolicyRequest.Actor fn := func( fldPath *field.Path, obj, oldObj *ateapipb.ObjectRef, @@ -576,16 +1199,12 @@ func Validate_DeleteAtespaceRequest( func() { // cohort = "atespace" earlyReturn := false if e := validate.Subfield(ctx, op, fldPath, obj, oldObj, "atespace", - func(o *ateapipb.ObjectRef) *string { return &o.Atespace }, validate.DirectEqual, validate.ForbiddenValue).MarkBeta().MarkShortCircuit(); len(e) != 0 { + func(o *ateapipb.ObjectRef) *string { return &o.Atespace }, validate.DirectEqual, validate.RequiredValue).MarkShortCircuit(); len(e) != 0 { errs = append(errs, e...) earlyReturn = true } if e := validate.Subfield(ctx, op, fldPath, obj, oldObj, "atespace", - func(o *ateapipb.ObjectRef) *string { return &o.Atespace }, validate.DirectEqual, validate.OptionalValue).MarkBeta().MarkShortCircuit(); len(e) != 0 { - earlyReturn = true - } - if e := validate.Subfield(ctx, op, fldPath, obj, oldObj, "atespace", - func(o *ateapipb.ObjectRef) *string { return &o.Atespace }, validate.DirectEqual, validate.OptionalValue).MarkBeta().MarkShortCircuit(); len(e) != 0 { + func(o *ateapipb.ObjectRef) *string { return &o.Atespace }, validate.DirectEqual, validate.OptionalValue).MarkShortCircuit(); len(e) != 0 { earlyReturn = true } if earlyReturn { @@ -597,10 +1216,10 @@ func Validate_DeleteAtespaceRequest( return } oldVal := safe.Field(oldObj, - func(oldObj *ateapipb.DeleteAtespaceRequest) *ateapipb.ObjectRef { - return oldObj.Atespace + func(oldObj *ateapipb.GetActorEgressPolicyRequest) *ateapipb.ObjectRef { + return oldObj.Actor }) - errs = append(errs, fn(fldPath.Child("atespace"), obj.Atespace, oldVal, oldObj != nil)...) + errs = append(errs, fn(fldPath.Child("actor"), obj.Actor, oldVal, oldObj != nil)...) } return errs @@ -665,6 +1284,92 @@ func Validate_GetAtespaceRequest( return errs } +// Validate_HostnameMatch validates an instance of HostnameMatch according +// to declarative validation rules in the API schema. +func Validate_HostnameMatch( + ctx context.Context, op operation.Operation, fldPath *field.Path, + obj, oldObj *ateapipb.HostnameMatch) (errs field.ErrorList) { + + // custom validation + if e := ValidateCustom_HostnameMatch(ctx, op, fldPath, obj, oldObj); len(e) != 0 { + errs = append(errs, e...) + } + + { // field ateapipb.HostnameMatch.Pattern + fn := func( + fldPath *field.Path, + obj, oldObj *string, + oldValueCorrelated bool) (errs field.ErrorList) { + // don't revalidate unchanged data + if oldValueCorrelated && op.Type == operation.Update { + if obj == oldObj || (obj != nil && oldObj != nil && *obj == *oldObj) { + return nil + } + } + // call field-attached validations + earlyReturn := false + if e := validate.RequiredValue(ctx, op, fldPath, obj, oldObj).MarkShortCircuit(); len(e) != 0 { + errs = append(errs, e...) + earlyReturn = true + } + if earlyReturn { + return // do not proceed + } + return + } + oldVal := safe.Field(oldObj, + func(oldObj *ateapipb.HostnameMatch) *string { + return &oldObj.Pattern + }) + errs = append(errs, fn(fldPath.Child("pattern"), &obj.Pattern, oldVal, oldObj != nil)...) + } + + return errs +} + +// Validate_IPBlockMatch validates an instance of IPBlockMatch according +// to declarative validation rules in the API schema. +func Validate_IPBlockMatch( + ctx context.Context, op operation.Operation, fldPath *field.Path, + obj, oldObj *ateapipb.IPBlockMatch) (errs field.ErrorList) { + + // custom validation + if e := ValidateCustom_IPBlockMatch(ctx, op, fldPath, obj, oldObj); len(e) != 0 { + errs = append(errs, e...) + } + + { // field ateapipb.IPBlockMatch.Cidr + fn := func( + fldPath *field.Path, + obj, oldObj *string, + oldValueCorrelated bool) (errs field.ErrorList) { + // don't revalidate unchanged data + if oldValueCorrelated && op.Type == operation.Update { + if obj == oldObj || (obj != nil && oldObj != nil && *obj == *oldObj) { + return nil + } + } + // call field-attached validations + earlyReturn := false + if e := validate.RequiredValue(ctx, op, fldPath, obj, oldObj).MarkShortCircuit(); len(e) != 0 { + errs = append(errs, e...) + earlyReturn = true + } + if earlyReturn { + return // do not proceed + } + return + } + oldVal := safe.Field(oldObj, + func(oldObj *ateapipb.IPBlockMatch) *string { + return &oldObj.Cidr + }) + errs = append(errs, fn(fldPath.Child("cidr"), &obj.Cidr, oldVal, oldObj != nil)...) + } + + return errs +} + // Validate_ListAtespacesRequest validates an instance of ListAtespacesRequest according // to declarative validation rules in the API schema. func Validate_ListAtespacesRequest( @@ -1088,6 +1793,171 @@ func Validate_Selector( return errs } +// Validate_StaticHeaderInjection validates an instance of StaticHeaderInjection according +// to declarative validation rules in the API schema. +func Validate_StaticHeaderInjection( + ctx context.Context, op operation.Operation, fldPath *field.Path, + obj, oldObj *ateapipb.StaticHeaderInjection) (errs field.ErrorList) { + + // custom validation + if e := ValidateCustom_StaticHeaderInjection(ctx, op, fldPath, obj, oldObj); len(e) != 0 { + errs = append(errs, e...) + } + + { // field ateapipb.StaticHeaderInjection.Header + fn := func( + fldPath *field.Path, + obj, oldObj *string, + oldValueCorrelated bool) (errs field.ErrorList) { + // don't revalidate unchanged data + if oldValueCorrelated && op.Type == operation.Update { + if obj == oldObj || (obj != nil && oldObj != nil && *obj == *oldObj) { + return nil + } + } + // call field-attached validations + earlyReturn := false + if e := validate.RequiredValue(ctx, op, fldPath, obj, oldObj).MarkShortCircuit(); len(e) != 0 { + errs = append(errs, e...) + earlyReturn = true + } + if earlyReturn { + return // do not proceed + } + return + } + oldVal := safe.Field(oldObj, + func(oldObj *ateapipb.StaticHeaderInjection) *string { + return &oldObj.Header + }) + errs = append(errs, fn(fldPath.Child("header"), &obj.Header, oldVal, oldObj != nil)...) + } + + // field ateapipb.StaticHeaderInjection.Prefix has no validation + + { // field ateapipb.StaticHeaderInjection.CredentialUri + fn := func( + fldPath *field.Path, + obj, oldObj *string, + oldValueCorrelated bool) (errs field.ErrorList) { + // don't revalidate unchanged data + if oldValueCorrelated && op.Type == operation.Update { + if obj == oldObj || (obj != nil && oldObj != nil && *obj == *oldObj) { + return nil + } + } + // call field-attached validations + earlyReturn := false + if e := validate.RequiredValue(ctx, op, fldPath, obj, oldObj).MarkShortCircuit(); len(e) != 0 { + errs = append(errs, e...) + earlyReturn = true + } + if earlyReturn { + return // do not proceed + } + return + } + oldVal := safe.Field(oldObj, + func(oldObj *ateapipb.StaticHeaderInjection) *string { + return &oldObj.CredentialUri + }) + errs = append(errs, fn(fldPath.Child("credential_uri"), &obj.CredentialUri, oldVal, oldObj != nil)...) + } + + return errs +} + +// Validate_UpdateActorEgressPolicyRequest validates an instance of UpdateActorEgressPolicyRequest according +// to declarative validation rules in the API schema. +func Validate_UpdateActorEgressPolicyRequest( + ctx context.Context, op operation.Operation, fldPath *field.Path, + obj, oldObj *ateapipb.UpdateActorEgressPolicyRequest) (errs field.ErrorList) { + + // custom validation + if e := ValidateCustom_UpdateActorEgressPolicyRequest(ctx, op, fldPath, obj, oldObj); len(e) != 0 { + errs = append(errs, e...) + } + + { // field ateapipb.UpdateActorEgressPolicyRequest.Actor + fn := func( + fldPath *field.Path, + obj, oldObj *ateapipb.ObjectRef, + 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.RequiredPointer(ctx, op, fldPath, obj, oldObj).MarkShortCircuit(); len(e) != 0 { + errs = append(errs, e...) + earlyReturn = true + } + if earlyReturn { + return // do not proceed + } + func() { // cohort = "atespace" + earlyReturn := false + if e := validate.Subfield(ctx, op, fldPath, obj, oldObj, "atespace", + func(o *ateapipb.ObjectRef) *string { return &o.Atespace }, validate.DirectEqual, validate.RequiredValue).MarkShortCircuit(); len(e) != 0 { + errs = append(errs, e...) + earlyReturn = true + } + if e := validate.Subfield(ctx, op, fldPath, obj, oldObj, "atespace", + func(o *ateapipb.ObjectRef) *string { return &o.Atespace }, validate.DirectEqual, validate.OptionalValue).MarkShortCircuit(); len(e) != 0 { + earlyReturn = true + } + if earlyReturn { + return // do not proceed + } + }() + // call the type's validation function + errs = append(errs, Validate_ObjectRef(ctx, op, fldPath, obj, oldObj)...) + return + } + oldVal := safe.Field(oldObj, + func(oldObj *ateapipb.UpdateActorEgressPolicyRequest) *ateapipb.ObjectRef { + return oldObj.Actor + }) + errs = append(errs, fn(fldPath.Child("actor"), obj.Actor, oldVal, oldObj != nil)...) + } + + { // field ateapipb.UpdateActorEgressPolicyRequest.EgressPolicy + 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.RequiredPointer(ctx, op, fldPath, obj, oldObj).MarkShortCircuit(); len(e) != 0 { + errs = append(errs, e...) + 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.UpdateActorEgressPolicyRequest) *ateapipb.EgressPolicy { + return oldObj.EgressPolicy + }) + errs = append(errs, fn(fldPath.Child("egress_policy"), obj.EgressPolicy, oldVal, oldObj != nil)...) + } + + return errs +} + // Validate_UpdateActorRequest validates an instance of UpdateActorRequest according // to declarative validation rules in the API schema. func Validate_UpdateActorRequest( diff --git a/cmd/ateapi/internal/store/atepg/atepg.go b/cmd/ateapi/internal/store/atepg/atepg.go index a84108705..35b6904bb 100644 --- a/cmd/ateapi/internal/store/atepg/atepg.go +++ b/cmd/ateapi/internal/store/atepg/atepg.go @@ -836,6 +836,116 @@ func (p *Persistence) listActorsGlobal(ctx context.Context, pageSize int32, page return result, nextToken, nil } +// --- Actor egress policies --- + +func (p *Persistence) CreateEgressPolicy(ctx context.Context, actorRef resources.ActorRef, policy *ateapipb.EgressPolicy) (*ateapipb.EgressPolicy, error) { + dbPolicy := proto.Clone(policy).(*ateapipb.EgressPolicy) + dbPolicy.Metadata = newCreateMetadata(actorRef.Atespace, "default") + protoBytes, err := proto.Marshal(dbPolicy) + if err != nil { + return nil, fmt.Errorf("marshaling egress policy: %w", err) + } + _, err = p.pool.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 { + if isUniqueViolation(err) { + return nil, store.ErrAlreadyExists + } + if isForeignKeyViolation(err) { + return nil, store.ErrFailedPrecondition + } + return nil, fmt.Errorf("inserting egress policy for %s: %w", actorRef, err) + } + return dbPolicy, nil +} + +func (p *Persistence) GetEgressPolicy(ctx context.Context, actorRef resources.ActorRef) (*ateapipb.EgressPolicy, error) { + return getEgressPolicyRow(ctx, p.pool, ` + SELECT uid, version, proto FROM actor_egress_policies + WHERE atespace = $1 AND actor_name = $2`, actorRef.Atespace, actorRef.Name) +} + +func (p *Persistence) UpdateEgressPolicy(ctx context.Context, actorRef resources.ActorRef, precondition store.Precondition, mutate func(*ateapipb.EgressPolicy) error) (*ateapipb.EgressPolicy, error) { + if err := precondition.Validate(); err != nil { + return nil, err + } + tx, err := p.pool.Begin(ctx) + if err != nil { + return nil, fmt.Errorf("beginning egress policy update: %w", err) + } + defer tx.Rollback(ctx) //nolint:errcheck // no-op once committed + + current, err := getEgressPolicyRow(ctx, tx, ` + SELECT uid, version, proto FROM actor_egress_policies + WHERE atespace = $1 AND actor_name = $2 FOR UPDATE`, actorRef.Atespace, actorRef.Name) + if err != nil { + return nil, err + } + if err := precondition.Check(current.GetMetadata()); err != nil { + return nil, err + } + updated := proto.Clone(current).(*ateapipb.EgressPolicy) + if err := mutate(updated); err != nil { + return nil, err + } + updated.Metadata = newUpdateMetadata(current.GetMetadata()) + protoBytes, err := proto.Marshal(updated) + if err != nil { + return nil, fmt.Errorf("marshaling updated egress policy: %w", err) + } + if _, err := tx.Exec(ctx, ` + UPDATE actor_egress_policies SET version = $3, proto = $4 + WHERE atespace = $1 AND actor_name = $2`, actorRef.Atespace, actorRef.Name, updated.GetMetadata().GetVersion(), protoBytes); err != nil { + return nil, fmt.Errorf("updating egress policy for %s: %w", actorRef, err) + } + if err := tx.Commit(ctx); err != nil { + return nil, fmt.Errorf("committing egress policy update: %w", err) + } + return updated, nil +} + +func (p *Persistence) DeleteEgressPolicy(ctx context.Context, actorRef resources.ActorRef) (*ateapipb.EgressPolicy, error) { + var version int64 + var uid string + var protoBytes []byte + err := p.pool.QueryRow(ctx, ` + DELETE FROM actor_egress_policies + WHERE atespace = $1 AND actor_name = $2 + RETURNING uid, version, proto`, actorRef.Atespace, actorRef.Name).Scan(&uid, &version, &protoBytes) + if errors.Is(err, pgx.ErrNoRows) { + return nil, store.ErrNotFound + } + if err != nil { + return nil, fmt.Errorf("deleting egress policy for %s: %w", actorRef, err) + } + return unmarshalEgressPolicy(uid, version, protoBytes) +} + +func getEgressPolicyRow(ctx context.Context, q querier, query string, args ...any) (*ateapipb.EgressPolicy, error) { + var uid string + var version int64 + var protoBytes []byte + if err := q.QueryRow(ctx, query, args...).Scan(&uid, &version, &protoBytes); err != nil { + if errors.Is(err, pgx.ErrNoRows) { + return nil, store.ErrNotFound + } + return nil, fmt.Errorf("getting egress policy: %w", err) + } + return unmarshalEgressPolicy(uid, version, protoBytes) +} + +func unmarshalEgressPolicy(uid string, version int64, protoBytes []byte) (*ateapipb.EgressPolicy, error) { + policy := &ateapipb.EgressPolicy{} + if err := proto.Unmarshal(protoBytes, policy); err != nil { + return nil, fmt.Errorf("unmarshaling egress policy: %w", err) + } + if err := validateProtoMetadataMatchesColumns("egress policy", policy.GetMetadata(), uid, version); err != nil { + return nil, err + } + return policy, nil +} + // --- Actor snapshots --- func (p *Persistence) CreateActorSnapshot(ctx context.Context, snapshot *ateapipb.ActorSnapshot) (*ateapipb.ActorSnapshot, error) { @@ -1514,7 +1624,7 @@ func (p *Persistence) releaseLease(ctx context.Context, key, token string) error // --- Debug --- func (p *Persistence) DebugClearAll(ctx context.Context) error { - if _, err := p.pool.Exec(ctx, `TRUNCATE atespaces, actors, actor_templates, actor_snapshots, actor_snapshot_tags, workers, leases, worker_outbox, worker_outbox_trim`); err != nil { + if _, err := p.pool.Exec(ctx, `TRUNCATE atespaces, actors, actor_egress_policies, actor_templates, actor_snapshots, actor_snapshot_tags, workers, leases, worker_outbox, worker_outbox_trim`); err != nil { return fmt.Errorf("truncating tables: %w", err) } return nil diff --git a/cmd/ateapi/internal/store/atepg/schema.go b/cmd/ateapi/internal/store/atepg/schema.go index fae80f1ac..5c301b1cd 100644 --- a/cmd/ateapi/internal/store/atepg/schema.go +++ b/cmd/ateapi/internal/store/atepg/schema.go @@ -44,6 +44,17 @@ CREATE TABLE IF NOT EXISTS actors ( PRIMARY KEY (atespace, name) ); +CREATE TABLE IF NOT EXISTS actor_egress_policies ( + atespace text NOT NULL, + actor_name text NOT NULL, + uid text NOT NULL, + version bigint NOT NULL, + proto bytea NOT NULL, + PRIMARY KEY (atespace, actor_name), + FOREIGN KEY (atespace, actor_name) + REFERENCES actors(atespace, name) ON DELETE CASCADE +); + CREATE TABLE IF NOT EXISTS actor_templates ( atespace text NOT NULL REFERENCES atespaces(name) ON DELETE RESTRICT, diff --git a/cmd/ateapi/internal/store/store.go b/cmd/ateapi/internal/store/store.go index 194e449de..ac5e02f85 100644 --- a/cmd/ateapi/internal/store/store.go +++ b/cmd/ateapi/internal/store/store.go @@ -104,6 +104,16 @@ type Interface interface { // missing, or ErrFailedPrecondition if not already deleting. DeleteActor(ctx context.Context, actorRef resources.ActorRef) (*ateapipb.Actor, error) + // Creates the 1:1 policy subresource for an existing Actor. + CreateEgressPolicy(ctx context.Context, actorRef resources.ActorRef, policy *ateapipb.EgressPolicy) (*ateapipb.EgressPolicy, error) + // Fetches an Actor's policy subresource. + GetEgressPolicy(ctx context.Context, actorRef resources.ActorRef) (*ateapipb.EgressPolicy, error) + // Transactionally updates an Actor's policy when its current UID and version + // match the precondition. + UpdateEgressPolicy(ctx context.Context, actorRef resources.ActorRef, precondition Precondition, mutate func(*ateapipb.EgressPolicy) error) (*ateapipb.EgressPolicy, error) + // Deletes and returns an Actor's policy subresource. + DeleteEgressPolicy(ctx context.Context, actorRef resources.ActorRef) (*ateapipb.EgressPolicy, error) + // Creates an immutable ActorSnapshot. The caller sets snapshot_uri; the // store keeps no location of its own. CreateActorSnapshot(ctx context.Context, snapshot *ateapipb.ActorSnapshot) (*ateapipb.ActorSnapshot, error) diff --git a/cmd/ateapi/internal/store/storecontract/contract.go b/cmd/ateapi/internal/store/storecontract/contract.go index b49151bde..31e8e26ed 100644 --- a/cmd/ateapi/internal/store/storecontract/contract.go +++ b/cmd/ateapi/internal/store/storecontract/contract.go @@ -28,6 +28,7 @@ import ( "github.com/google/go-cmp/cmp" "google.golang.org/protobuf/proto" "google.golang.org/protobuf/testing/protocmp" + "google.golang.org/protobuf/types/known/emptypb" "google.golang.org/protobuf/types/known/timestamppb" "github.com/agent-substrate/substrate/cmd/ateapi/internal/store" @@ -134,6 +135,7 @@ func receiveEvent(t *testing.T, ch <-chan store.WorkerEvent) store.WorkerEvent { // notifications is not covered here; see atepg's own test file for that. func RunContractTests(t *testing.T, setup func(t *testing.T) store.Interface) { runActorContractTests(t, setup) + runEgressPolicyContractTests(t, setup) runWorkerContractTests(t, setup) runAtespaceContractTests(t, setup) runActorTemplateContractTests(t, setup) @@ -143,6 +145,110 @@ func RunContractTests(t *testing.T, setup func(t *testing.T) store.Interface) { runDebugContractTests(t, setup) } +func runEgressPolicyContractTests(t *testing.T, setup func(t *testing.T) store.Interface) { + t.Helper() + + t.Run("EgressPolicy_Lifecycle", func(t *testing.T) { + s := setup(t) + ctx := context.Background() + mustCreateAtespace(t, s, testAtespace) + actor, err := s.CreateActor(ctx, &ateapipb.Actor{ + Metadata: &ateapipb.ResourceMetadata{Atespace: testAtespace, Name: "session-1"}, + Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_RUNNING}, + }) + if err != nil { + t.Fatal(err) + } + actorRef := resources.ActorRefFromActor(actor) + policy := &ateapipb.EgressPolicy{Rules: []*ateapipb.EgressRule{{Allow: []*ateapipb.EgressMatch{{ + Hostname: &ateapipb.HostnameMatch{Pattern: "api.example.com"}, + }}}}} + + created, err := s.CreateEgressPolicy(ctx, actorRef, policy) + if err != nil { + t.Fatalf("CreateEgressPolicy failed: %v", err) + } + if md := created.GetMetadata(); md.GetName() != "default" || md.GetAtespace() != testAtespace || md.GetUid() == "" || md.GetVersion() != 1 || md.GetCreateTime() == nil || md.GetUpdateTime() == nil { + t.Fatalf("created metadata = %v", md) + } + if policy.GetMetadata() != nil { + t.Fatalf("input metadata = %v; want nil", policy.GetMetadata()) + } + if _, err := s.CreateEgressPolicy(ctx, actorRef, policy); !errors.Is(err, store.ErrAlreadyExists) { + t.Fatalf("duplicate create error = %v, want ErrAlreadyExists", err) + } + got, err := s.GetEgressPolicy(ctx, actorRef) + if err != nil || !proto.Equal(got, created) { + t.Fatalf("GetEgressPolicy = %v, %v; want %v", got, err, created) + } + if _, err := s.UpdateEgressPolicy(ctx, actorRef, store.Precondition{}, func(*ateapipb.EgressPolicy) error { return nil }); !errors.Is(err, store.ErrPreconditionRequired) { + t.Fatalf("unguarded update error = %v, want ErrPreconditionRequired", err) + } + if _, err := s.UpdateEgressPolicy(ctx, actorRef, store.Precondition{UID: created.GetMetadata().GetUid(), Version: 99}, func(*ateapipb.EgressPolicy) error { return nil }); !errors.Is(err, store.ErrVersionConflict) { + t.Fatalf("stale update error = %v, want ErrVersionConflict", err) + } + if _, err := s.UpdateEgressPolicy(ctx, actorRef, store.Precondition{UID: "replacement-uid", Version: 1}, func(*ateapipb.EgressPolicy) error { return nil }); !errors.Is(err, store.ErrUIDConflict) { + t.Fatalf("wrong UID update error = %v, want ErrUIDConflict", err) + } + updated, err := s.UpdateEgressPolicy(ctx, actorRef, store.PreconditionFrom(created), func(policy *ateapipb.EgressPolicy) error { + policy.Metadata.Atespace = "other" + policy.Metadata.Name = "other" + policy.Rules = []*ateapipb.EgressRule{{Allow: []*ateapipb.EgressMatch{{All: &emptypb.Empty{}}}}} + return nil + }) + if err != nil || updated.GetMetadata().GetAtespace() != testAtespace || updated.GetMetadata().GetName() != "default" || updated.GetMetadata().GetVersion() != 2 || updated.GetMetadata().GetUid() != created.GetMetadata().GetUid() { + t.Fatalf("UpdateEgressPolicy = %v, %v; want version 2", updated, err) + } + deleted, err := s.DeleteEgressPolicy(ctx, actorRef) + if err != nil || !proto.Equal(deleted, updated) { + t.Fatalf("DeleteEgressPolicy = %v, %v; want %v", deleted, err, updated) + } + if _, err := s.GetEgressPolicy(ctx, actorRef); !errors.Is(err, store.ErrNotFound) { + t.Fatalf("GetEgressPolicy after delete error = %v, want ErrNotFound", err) + } + }) + + t.Run("EgressPolicy_ActorLifecycle", func(t *testing.T) { + s := setup(t) + ctx := context.Background() + mustCreateAtespace(t, s, testAtespace) + actorRef := resources.ActorRef{Atespace: testAtespace, Name: "session-1"} + policy := &ateapipb.EgressPolicy{} + if _, err := s.CreateEgressPolicy(ctx, actorRef, policy); !errors.Is(err, store.ErrFailedPrecondition) { + t.Fatalf("policy without Actor error = %v, want ErrFailedPrecondition", err) + } + actor, err := s.CreateActor(ctx, &ateapipb.Actor{ + Metadata: &ateapipb.ResourceMetadata{Atespace: testAtespace, Name: actorRef.Name}, + Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_DELETING}, + }) + if err != nil { + t.Fatal(err) + } + if _, err := s.CreateEgressPolicy(ctx, actorRef, policy); err != nil { + t.Fatal(err) + } + if _, err := s.DeleteActor(ctx, actorRef); err != nil { + t.Fatal(err) + } + if _, err := s.GetEgressPolicy(ctx, actorRef); !errors.Is(err, store.ErrNotFound) { + t.Fatalf("policy after Actor deletion error = %v, want ErrNotFound", err) + } + replacement, err := s.CreateActor(ctx, &ateapipb.Actor{ + Metadata: &ateapipb.ResourceMetadata{Atespace: testAtespace, Name: actorRef.Name}, + Status: &ateapipb.ActorStatus{State: ateapipb.ActorState_ACTOR_STATE_RUNNING}, + }) + if err != nil { + t.Fatal(err) + } + if replacement.GetMetadata().GetUid() == actor.GetMetadata().GetUid() { + t.Fatal("replacement Actor reused UID") + } + if _, err := s.GetEgressPolicy(ctx, actorRef); !errors.Is(err, store.ErrNotFound) { + t.Fatalf("replacement Actor inherited policy: %v", err) + } + }) +} + func runListOptionsContractTests(t *testing.T, setup func(t *testing.T) store.Interface) { t.Helper() diff --git a/pkg/proto/ateapipb/ateapi.pb.go b/pkg/proto/ateapipb/ateapi.pb.go index a37128f43..d1025805d 100644 --- a/pkg/proto/ateapipb/ateapi.pb.go +++ b/pkg/proto/ateapipb/ateapi.pb.go @@ -23,6 +23,7 @@ package ateapipb import ( protoreflect "google.golang.org/protobuf/reflect/protoreflect" protoimpl "google.golang.org/protobuf/runtime/protoimpl" + emptypb "google.golang.org/protobuf/types/known/emptypb" timestamppb "google.golang.org/protobuf/types/known/timestamppb" reflect "reflect" sync "sync" @@ -980,6 +981,597 @@ func (x *Actor) GetStatus() *ActorStatus { return nil } +// EgressPolicy is an egress policy resource nested under an Actor. An Actor has +// at most one egress policy resource, named "default". +// +// +k8s:customValidation +type EgressPolicy struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Standard resource metadata. Atespace must match the parent Actor and name + // must be "default". Both are caller-specified on create and immutable. + // UID, version, create_time, and update_time are server-managed. + // + // +k8s:required + // +k8s:subfield(atespace)=+k8s:required + Metadata *ResourceMetadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"` + // A request is authorized when at least one rule matches. Effects from all + // matching rules are then applied once per rule. Rule order has no meaning. + // An empty rule list denies all traffic. + // + // +k8s:optional + Rules []*EgressRule `protobuf:"bytes,2,rep,name=rules,proto3" json:"rules,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *EgressPolicy) Reset() { + *x = EgressPolicy{} + mi := &file_ateapi_proto_msgTypes[5] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *EgressPolicy) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EgressPolicy) ProtoMessage() {} + +func (x *EgressPolicy) ProtoReflect() protoreflect.Message { + mi := &file_ateapi_proto_msgTypes[5] + 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 EgressPolicy.ProtoReflect.Descriptor instead. +func (*EgressPolicy) Descriptor() ([]byte, []int) { + return file_ateapi_proto_rawDescGZIP(), []int{5} +} + +func (x *EgressPolicy) GetMetadata() *ResourceMetadata { + if x != nil { + return x.Metadata + } + return nil +} + +func (x *EgressPolicy) GetRules() []*EgressRule { + if x != nil { + return x.Rules + } + return nil +} + +type EgressRule struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Entries are ORed. The rule matches when any entry matches. + // + // +k8s:required + Allow []*EgressMatch `protobuf:"bytes,1,rep,name=allow,proto3" json:"allow,omitempty"` + // Effects do not authorize traffic. They are applied only after at least one + // rule authorizes the request. + // + // +k8s:optional + Effects *EgressRuleEffects `protobuf:"bytes,2,opt,name=effects,proto3" json:"effects,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *EgressRule) Reset() { + *x = EgressRule{} + mi := &file_ateapi_proto_msgTypes[6] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *EgressRule) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EgressRule) ProtoMessage() {} + +func (x *EgressRule) ProtoReflect() protoreflect.Message { + mi := &file_ateapi_proto_msgTypes[6] + if x != nil { + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + if ms.LoadMessageInfo() == nil { + ms.StoreMessageInfo(mi) + } + return ms + } + return mi.MessageOf(x) +} + +// Deprecated: Use EgressRule.ProtoReflect.Descriptor instead. +func (*EgressRule) Descriptor() ([]byte, []int) { + return file_ateapi_proto_rawDescGZIP(), []int{6} +} + +func (x *EgressRule) GetAllow() []*EgressMatch { + if x != nil { + return x.Allow + } + return nil +} + +func (x *EgressRule) GetEffects() *EgressRuleEffects { + if x != nil { + return x.Effects + } + return nil +} + +type EgressMatch struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Matches every destination. Exactly one predicate must be set. + // + // +k8s:optional + // +k8s:unionMember + // +k8s:opaqueType + All *emptypb.Empty `protobuf:"bytes,1,opt,name=all,proto3" json:"all,omitempty"` + // Matches when the request hostname satisfies the configured pattern. + // + // +k8s:optional + // +k8s:unionMember + Hostname *HostnameMatch `protobuf:"bytes,2,opt,name=hostname,proto3" json:"hostname,omitempty"` + // Matches when the original destination IP belongs to the configured block. + // + // +k8s:optional + // +k8s:unionMember + IpBlock *IPBlockMatch `protobuf:"bytes,3,opt,name=ip_block,json=ipBlock,proto3" json:"ip_block,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *EgressMatch) Reset() { + *x = EgressMatch{} + mi := &file_ateapi_proto_msgTypes[7] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *EgressMatch) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EgressMatch) ProtoMessage() {} + +func (x *EgressMatch) ProtoReflect() protoreflect.Message { + mi := &file_ateapi_proto_msgTypes[7] + 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 EgressMatch.ProtoReflect.Descriptor instead. +func (*EgressMatch) Descriptor() ([]byte, []int) { + return file_ateapi_proto_rawDescGZIP(), []int{7} +} + +func (x *EgressMatch) GetAll() *emptypb.Empty { + if x != nil { + return x.All + } + return nil +} + +func (x *EgressMatch) GetHostname() *HostnameMatch { + if x != nil { + return x.Hostname + } + return nil +} + +func (x *EgressMatch) GetIpBlock() *IPBlockMatch { + if x != nil { + return x.IpBlock + } + return nil +} + +// +k8s:customValidation +type HostnameMatch struct { + state protoimpl.MessageState `protogen:"open.v1"` + // An ASCII DNS name, or a wildcard in the complete leftmost label. + // + // The pattern and candidate hostname are normalized to lowercase. One + // trailing dot is permitted and removed. An optional port is removed from an + // HTTP authority before candidate normalization. All labels must be non-empty + // DNS labels of at most 63 characters, containing only ASCII letters, digits, + // and hyphens, and must start and end with a letter or digit. The normalized + // name must be at most 253 characters. + // + // A pattern without a wildcard matches only the complete normalized name. + // "*.example.com" matches exactly one non-empty label, such as + // "api.example.com". It does not match "example.com" or + // "nested.api.example.com". No other wildcard syntax is accepted. + // + // The pattern must not be a URL, IP literal, host:port authority, or Unicode + // U-label. An IP-literal candidate never matches. Internationalized names + // must use their ASCII IDNA A-label form; no Unicode conversion is done. + // Empty labels, malformed authorities, and more than one trailing dot are + // invalid and fail closed. + // + // +k8s:required + Pattern string `protobuf:"bytes,1,opt,name=pattern,proto3" json:"pattern,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *HostnameMatch) Reset() { + *x = HostnameMatch{} + mi := &file_ateapi_proto_msgTypes[8] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *HostnameMatch) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*HostnameMatch) ProtoMessage() {} + +func (x *HostnameMatch) 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 HostnameMatch.ProtoReflect.Descriptor instead. +func (*HostnameMatch) Descriptor() ([]byte, []int) { + return file_ateapi_proto_rawDescGZIP(), []int{8} +} + +func (x *HostnameMatch) GetPattern() string { + if x != nil { + return x.Pattern + } + return "" +} + +// +k8s:customValidation +type IPBlockMatch struct { + state protoimpl.MessageState `protogen:"open.v1"` + // A canonical IPv4 or IPv6 CIDR prefix. The predicate matches when the + // original destination IP belongs to the prefix. + // + // +k8s:required + Cidr string `protobuf:"bytes,1,opt,name=cidr,proto3" json:"cidr,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *IPBlockMatch) Reset() { + *x = IPBlockMatch{} + mi := &file_ateapi_proto_msgTypes[9] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *IPBlockMatch) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*IPBlockMatch) ProtoMessage() {} + +func (x *IPBlockMatch) ProtoReflect() protoreflect.Message { + mi := &file_ateapi_proto_msgTypes[9] + 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 IPBlockMatch.ProtoReflect.Descriptor instead. +func (*IPBlockMatch) Descriptor() ([]byte, []int) { + return file_ateapi_proto_rawDescGZIP(), []int{9} +} + +func (x *IPBlockMatch) GetCidr() string { + if x != nil { + return x.Cidr + } + return "" +} + +// EgressRuleEffects contains non-mutually-exclusive effects. No two effects in +// a policy may target the same case-insensitive header. +type EgressRuleEffects struct { + state protoimpl.MessageState `protogen:"open.v1"` + // Injects values retrieved from credential providers into request headers. + // + // +k8s:optional + InjectStaticHeader []*StaticHeaderInjection `protobuf:"bytes,1,rep,name=inject_static_header,json=injectStaticHeader,proto3" json:"inject_static_header,omitempty"` + // Injects an Actor JWT, or its exchanged token, into a request header. + // + // +k8s:optional + InjectActorJwt *ActorTokenInjection `protobuf:"bytes,2,opt,name=inject_actor_jwt,json=injectActorJwt,proto3" json:"inject_actor_jwt,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *EgressRuleEffects) Reset() { + *x = EgressRuleEffects{} + mi := &file_ateapi_proto_msgTypes[10] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *EgressRuleEffects) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*EgressRuleEffects) ProtoMessage() {} + +func (x *EgressRuleEffects) ProtoReflect() protoreflect.Message { + mi := &file_ateapi_proto_msgTypes[10] + 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 EgressRuleEffects.ProtoReflect.Descriptor instead. +func (*EgressRuleEffects) Descriptor() ([]byte, []int) { + return file_ateapi_proto_rawDescGZIP(), []int{10} +} + +func (x *EgressRuleEffects) GetInjectStaticHeader() []*StaticHeaderInjection { + if x != nil { + return x.InjectStaticHeader + } + return nil +} + +func (x *EgressRuleEffects) GetInjectActorJwt() *ActorTokenInjection { + if x != nil { + return x.InjectActorJwt + } + return nil +} + +// +k8s:customValidation +type StaticHeaderInjection struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The case-insensitive HTTP request header to inject. + // + // +k8s:required + Header string `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + // For example, "Bearer " for the Authorization header. + Prefix string `protobuf:"bytes,2,opt,name=prefix,proto3" json:"prefix,omitempty"` + // Source-agnostic reference interpreted by a registered credential provider: + // substrate-secret://// + // + // +k8s:required + CredentialUri string `protobuf:"bytes,3,opt,name=credential_uri,json=credentialUri,proto3" json:"credential_uri,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *StaticHeaderInjection) Reset() { + *x = StaticHeaderInjection{} + mi := &file_ateapi_proto_msgTypes[11] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *StaticHeaderInjection) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*StaticHeaderInjection) ProtoMessage() {} + +func (x *StaticHeaderInjection) ProtoReflect() protoreflect.Message { + mi := &file_ateapi_proto_msgTypes[11] + 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 StaticHeaderInjection.ProtoReflect.Descriptor instead. +func (*StaticHeaderInjection) Descriptor() ([]byte, []int) { + return file_ateapi_proto_rawDescGZIP(), []int{11} +} + +func (x *StaticHeaderInjection) GetHeader() string { + if x != nil { + return x.Header + } + return "" +} + +func (x *StaticHeaderInjection) GetPrefix() string { + if x != nil { + return x.Prefix + } + return "" +} + +func (x *StaticHeaderInjection) GetCredentialUri() string { + if x != nil { + return x.CredentialUri + } + return "" +} + +// +k8s:customValidation +type ActorTokenInjection struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The case-insensitive HTTP request header to inject. + // + // +k8s:required + Header string `protobuf:"bytes,1,opt,name=header,proto3" json:"header,omitempty"` + // Audiences included in the minted Actor JWT. + Audiences []string `protobuf:"bytes,2,rep,name=audiences,proto3" json:"audiences,omitempty"` + // When present, exchanges the Actor JWT at an RFC 8693 endpoint and injects + // the result. A returned expires_in value controls caching of the token. + Rfc_8693Exchange *RFC8693ExchangeParameters `protobuf:"bytes,3,opt,name=rfc_8693_exchange,json=rfc8693Exchange,proto3" json:"rfc_8693_exchange,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ActorTokenInjection) Reset() { + *x = ActorTokenInjection{} + mi := &file_ateapi_proto_msgTypes[12] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ActorTokenInjection) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ActorTokenInjection) ProtoMessage() {} + +func (x *ActorTokenInjection) ProtoReflect() protoreflect.Message { + mi := &file_ateapi_proto_msgTypes[12] + 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 ActorTokenInjection.ProtoReflect.Descriptor instead. +func (*ActorTokenInjection) Descriptor() ([]byte, []int) { + return file_ateapi_proto_rawDescGZIP(), []int{12} +} + +func (x *ActorTokenInjection) GetHeader() string { + if x != nil { + return x.Header + } + return "" +} + +func (x *ActorTokenInjection) GetAudiences() []string { + if x != nil { + return x.Audiences + } + return nil +} + +func (x *ActorTokenInjection) GetRfc_8693Exchange() *RFC8693ExchangeParameters { + if x != nil { + return x.Rfc_8693Exchange + } + return nil +} + +type RFC8693ExchangeParameters struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The HTTPS URL of the RFC 8693 token exchange endpoint. + Url string `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"` + // Resource indicators sent in the token exchange request. + Resources []string `protobuf:"bytes,2,rep,name=resources,proto3" json:"resources,omitempty"` + // Audience values sent in the token exchange request. + Audiences []string `protobuf:"bytes,3,rep,name=audiences,proto3" json:"audiences,omitempty"` + // The requested access scope sent in the token exchange request. + Scope string `protobuf:"bytes,4,opt,name=scope,proto3" json:"scope,omitempty"` + // The requested token type sent in the token exchange request. + RequestedTokenType string `protobuf:"bytes,5,opt,name=requested_token_type,json=requestedTokenType,proto3" json:"requested_token_type,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *RFC8693ExchangeParameters) Reset() { + *x = RFC8693ExchangeParameters{} + mi := &file_ateapi_proto_msgTypes[13] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *RFC8693ExchangeParameters) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*RFC8693ExchangeParameters) ProtoMessage() {} + +func (x *RFC8693ExchangeParameters) ProtoReflect() protoreflect.Message { + mi := &file_ateapi_proto_msgTypes[13] + 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 RFC8693ExchangeParameters.ProtoReflect.Descriptor instead. +func (*RFC8693ExchangeParameters) Descriptor() ([]byte, []int) { + return file_ateapi_proto_rawDescGZIP(), []int{13} +} + +func (x *RFC8693ExchangeParameters) GetUrl() string { + if x != nil { + return x.Url + } + return "" +} + +func (x *RFC8693ExchangeParameters) GetResources() []string { + if x != nil { + return x.Resources + } + return nil +} + +func (x *RFC8693ExchangeParameters) GetAudiences() []string { + if x != nil { + return x.Audiences + } + return nil +} + +func (x *RFC8693ExchangeParameters) GetScope() string { + if x != nil { + return x.Scope + } + return "" +} + +func (x *RFC8693ExchangeParameters) GetRequestedTokenType() string { + if x != nil { + return x.RequestedTokenType + } + return "" +} + type ActorStatus struct { state protoimpl.MessageState `protogen:"open.v1"` // state is the Actor's current lifecycle state. @@ -1022,7 +1614,7 @@ type ActorStatus struct { func (x *ActorStatus) Reset() { *x = ActorStatus{} - mi := &file_ateapi_proto_msgTypes[5] + mi := &file_ateapi_proto_msgTypes[14] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1034,7 +1626,7 @@ func (x *ActorStatus) String() string { func (*ActorStatus) ProtoMessage() {} func (x *ActorStatus) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[5] + mi := &file_ateapi_proto_msgTypes[14] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1047,7 +1639,7 @@ func (x *ActorStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use ActorStatus.ProtoReflect.Descriptor instead. func (*ActorStatus) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{5} + return file_ateapi_proto_rawDescGZIP(), []int{14} } func (x *ActorStatus) GetState() ActorState { @@ -1129,7 +1721,7 @@ type ActorSourceSnapshotStatus struct { func (x *ActorSourceSnapshotStatus) Reset() { *x = ActorSourceSnapshotStatus{} - mi := &file_ateapi_proto_msgTypes[6] + mi := &file_ateapi_proto_msgTypes[15] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1141,7 +1733,7 @@ func (x *ActorSourceSnapshotStatus) String() string { func (*ActorSourceSnapshotStatus) ProtoMessage() {} func (x *ActorSourceSnapshotStatus) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[6] + mi := &file_ateapi_proto_msgTypes[15] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1154,7 +1746,7 @@ func (x *ActorSourceSnapshotStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use ActorSourceSnapshotStatus.ProtoReflect.Descriptor instead. func (*ActorSourceSnapshotStatus) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{6} + return file_ateapi_proto_rawDescGZIP(), []int{15} } func (x *ActorSourceSnapshotStatus) GetSnapshot() *ObjectRef { @@ -1222,7 +1814,7 @@ type WorkerAssignment struct { func (x *WorkerAssignment) Reset() { *x = WorkerAssignment{} - mi := &file_ateapi_proto_msgTypes[7] + mi := &file_ateapi_proto_msgTypes[16] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1234,7 +1826,7 @@ func (x *WorkerAssignment) String() string { func (*WorkerAssignment) ProtoMessage() {} func (x *WorkerAssignment) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[7] + mi := &file_ateapi_proto_msgTypes[16] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1247,7 +1839,7 @@ func (x *WorkerAssignment) ProtoReflect() protoreflect.Message { // Deprecated: Use WorkerAssignment.ProtoReflect.Descriptor instead. func (*WorkerAssignment) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{7} + return file_ateapi_proto_rawDescGZIP(), []int{16} } func (x *WorkerAssignment) GetWorker() *ObjectRef { @@ -1305,7 +1897,7 @@ type ActorSnapshot struct { func (x *ActorSnapshot) Reset() { *x = ActorSnapshot{} - mi := &file_ateapi_proto_msgTypes[8] + mi := &file_ateapi_proto_msgTypes[17] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1317,7 +1909,7 @@ func (x *ActorSnapshot) String() string { func (*ActorSnapshot) ProtoMessage() {} func (x *ActorSnapshot) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[8] + mi := &file_ateapi_proto_msgTypes[17] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1330,7 +1922,7 @@ func (x *ActorSnapshot) ProtoReflect() protoreflect.Message { // Deprecated: Use ActorSnapshot.ProtoReflect.Descriptor instead. func (*ActorSnapshot) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{8} + return file_ateapi_proto_rawDescGZIP(), []int{17} } func (x *ActorSnapshot) GetMetadata() *ResourceMetadata { @@ -1367,7 +1959,7 @@ type ActorSnapshotStatus struct { func (x *ActorSnapshotStatus) Reset() { *x = ActorSnapshotStatus{} - mi := &file_ateapi_proto_msgTypes[9] + mi := &file_ateapi_proto_msgTypes[18] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1379,7 +1971,7 @@ func (x *ActorSnapshotStatus) String() string { func (*ActorSnapshotStatus) ProtoMessage() {} func (x *ActorSnapshotStatus) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[9] + mi := &file_ateapi_proto_msgTypes[18] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1392,7 +1984,7 @@ func (x *ActorSnapshotStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use ActorSnapshotStatus.ProtoReflect.Descriptor instead. func (*ActorSnapshotStatus) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{9} + return file_ateapi_proto_rawDescGZIP(), []int{18} } func (x *ActorSnapshotStatus) GetSourceActor() *ObjectRef { @@ -1474,7 +2066,7 @@ type ActorSnapshotTag struct { func (x *ActorSnapshotTag) Reset() { *x = ActorSnapshotTag{} - mi := &file_ateapi_proto_msgTypes[10] + mi := &file_ateapi_proto_msgTypes[19] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1486,7 +2078,7 @@ func (x *ActorSnapshotTag) String() string { func (*ActorSnapshotTag) ProtoMessage() {} func (x *ActorSnapshotTag) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[10] + mi := &file_ateapi_proto_msgTypes[19] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1499,7 +2091,7 @@ func (x *ActorSnapshotTag) ProtoReflect() protoreflect.Message { // Deprecated: Use ActorSnapshotTag.ProtoReflect.Descriptor instead. func (*ActorSnapshotTag) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{10} + return file_ateapi_proto_rawDescGZIP(), []int{19} } func (x *ActorSnapshotTag) GetMetadata() *ResourceMetadata { @@ -1538,7 +2130,7 @@ type Atespace struct { func (x *Atespace) Reset() { *x = Atespace{} - mi := &file_ateapi_proto_msgTypes[11] + mi := &file_ateapi_proto_msgTypes[20] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1550,7 +2142,7 @@ func (x *Atespace) String() string { func (*Atespace) ProtoMessage() {} func (x *Atespace) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[11] + mi := &file_ateapi_proto_msgTypes[20] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1563,7 +2155,7 @@ func (x *Atespace) ProtoReflect() protoreflect.Message { // Deprecated: Use Atespace.ProtoReflect.Descriptor instead. func (*Atespace) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{11} + return file_ateapi_proto_rawDescGZIP(), []int{20} } func (x *Atespace) GetMetadata() *ResourceMetadata { @@ -1596,7 +2188,7 @@ type ObjectRef struct { func (x *ObjectRef) Reset() { *x = ObjectRef{} - mi := &file_ateapi_proto_msgTypes[12] + mi := &file_ateapi_proto_msgTypes[21] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1608,7 +2200,7 @@ func (x *ObjectRef) String() string { func (*ObjectRef) ProtoMessage() {} func (x *ObjectRef) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[12] + mi := &file_ateapi_proto_msgTypes[21] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1621,7 +2213,7 @@ func (x *ObjectRef) ProtoReflect() protoreflect.Message { // Deprecated: Use ObjectRef.ProtoReflect.Descriptor instead. func (*ObjectRef) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{12} + return file_ateapi_proto_rawDescGZIP(), []int{21} } func (x *ObjectRef) GetAtespace() string { @@ -1662,7 +2254,7 @@ type ActorTemplate struct { func (x *ActorTemplate) Reset() { *x = ActorTemplate{} - mi := &file_ateapi_proto_msgTypes[13] + mi := &file_ateapi_proto_msgTypes[22] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1674,7 +2266,7 @@ func (x *ActorTemplate) String() string { func (*ActorTemplate) ProtoMessage() {} func (x *ActorTemplate) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[13] + mi := &file_ateapi_proto_msgTypes[22] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1687,7 +2279,7 @@ func (x *ActorTemplate) ProtoReflect() protoreflect.Message { // Deprecated: Use ActorTemplate.ProtoReflect.Descriptor instead. func (*ActorTemplate) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{13} + return file_ateapi_proto_rawDescGZIP(), []int{22} } func (x *ActorTemplate) GetMetadata() *ResourceMetadata { @@ -1755,7 +2347,7 @@ type Resources struct { func (x *Resources) Reset() { *x = Resources{} - mi := &file_ateapi_proto_msgTypes[14] + mi := &file_ateapi_proto_msgTypes[23] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1767,7 +2359,7 @@ func (x *Resources) String() string { func (*Resources) ProtoMessage() {} func (x *Resources) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[14] + mi := &file_ateapi_proto_msgTypes[23] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1780,7 +2372,7 @@ func (x *Resources) ProtoReflect() protoreflect.Message { // Deprecated: Use Resources.ProtoReflect.Descriptor instead. func (*Resources) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{14} + return file_ateapi_proto_rawDescGZIP(), []int{23} } func (x *Resources) GetLimits() []*Limits { @@ -1800,7 +2392,7 @@ type Limits struct { func (x *Limits) Reset() { *x = Limits{} - mi := &file_ateapi_proto_msgTypes[15] + mi := &file_ateapi_proto_msgTypes[24] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1812,7 +2404,7 @@ func (x *Limits) String() string { func (*Limits) ProtoMessage() {} func (x *Limits) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[15] + mi := &file_ateapi_proto_msgTypes[24] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1825,7 +2417,7 @@ func (x *Limits) ProtoReflect() protoreflect.Message { // Deprecated: Use Limits.ProtoReflect.Descriptor instead. func (*Limits) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{15} + return file_ateapi_proto_rawDescGZIP(), []int{24} } func (x *Limits) GetName() string { @@ -1865,7 +2457,7 @@ type ActorTemplateStatus struct { func (x *ActorTemplateStatus) Reset() { *x = ActorTemplateStatus{} - mi := &file_ateapi_proto_msgTypes[16] + mi := &file_ateapi_proto_msgTypes[25] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1877,7 +2469,7 @@ func (x *ActorTemplateStatus) String() string { func (*ActorTemplateStatus) ProtoMessage() {} func (x *ActorTemplateStatus) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[16] + mi := &file_ateapi_proto_msgTypes[25] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1890,7 +2482,7 @@ func (x *ActorTemplateStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use ActorTemplateStatus.ProtoReflect.Descriptor instead. func (*ActorTemplateStatus) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{16} + return file_ateapi_proto_rawDescGZIP(), []int{25} } func (x *ActorTemplateStatus) GetPhase() ActorTemplatePhase { @@ -1936,7 +2528,7 @@ type SandboxConfig struct { func (x *SandboxConfig) Reset() { *x = SandboxConfig{} - mi := &file_ateapi_proto_msgTypes[17] + mi := &file_ateapi_proto_msgTypes[26] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -1948,7 +2540,7 @@ func (x *SandboxConfig) String() string { func (*SandboxConfig) ProtoMessage() {} func (x *SandboxConfig) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[17] + mi := &file_ateapi_proto_msgTypes[26] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -1961,7 +2553,7 @@ func (x *SandboxConfig) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxConfig.ProtoReflect.Descriptor instead. func (*SandboxConfig) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{17} + return file_ateapi_proto_rawDescGZIP(), []int{26} } func (x *SandboxConfig) GetSandboxClass() SandboxClass { @@ -1997,7 +2589,7 @@ type SnapshotsConfig struct { func (x *SnapshotsConfig) Reset() { *x = SnapshotsConfig{} - mi := &file_ateapi_proto_msgTypes[18] + mi := &file_ateapi_proto_msgTypes[27] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2009,7 +2601,7 @@ func (x *SnapshotsConfig) String() string { func (*SnapshotsConfig) ProtoMessage() {} func (x *SnapshotsConfig) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[18] + mi := &file_ateapi_proto_msgTypes[27] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2022,7 +2614,7 @@ func (x *SnapshotsConfig) ProtoReflect() protoreflect.Message { // Deprecated: Use SnapshotsConfig.ProtoReflect.Descriptor instead. func (*SnapshotsConfig) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{18} + return file_ateapi_proto_rawDescGZIP(), []int{27} } func (x *SnapshotsConfig) GetOnPause() SnapshotContentScope { @@ -2068,7 +2660,7 @@ type OnResumeConfig struct { func (x *OnResumeConfig) Reset() { *x = OnResumeConfig{} - mi := &file_ateapi_proto_msgTypes[19] + mi := &file_ateapi_proto_msgTypes[28] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2080,7 +2672,7 @@ func (x *OnResumeConfig) String() string { func (*OnResumeConfig) ProtoMessage() {} func (x *OnResumeConfig) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[19] + mi := &file_ateapi_proto_msgTypes[28] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2093,7 +2685,7 @@ func (x *OnResumeConfig) ProtoReflect() protoreflect.Message { // Deprecated: Use OnResumeConfig.ProtoReflect.Descriptor instead. func (*OnResumeConfig) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{19} + return file_ateapi_proto_rawDescGZIP(), []int{28} } func (x *OnResumeConfig) GetFromData() ResumeSource { @@ -2126,7 +2718,7 @@ type Container struct { func (x *Container) Reset() { *x = Container{} - mi := &file_ateapi_proto_msgTypes[20] + mi := &file_ateapi_proto_msgTypes[29] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2138,7 +2730,7 @@ func (x *Container) String() string { func (*Container) ProtoMessage() {} func (x *Container) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[20] + mi := &file_ateapi_proto_msgTypes[29] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2151,7 +2743,7 @@ func (x *Container) ProtoReflect() protoreflect.Message { // Deprecated: Use Container.ProtoReflect.Descriptor instead. func (*Container) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{20} + return file_ateapi_proto_rawDescGZIP(), []int{29} } func (x *Container) GetName() string { @@ -2217,7 +2809,7 @@ type EnvVar struct { func (x *EnvVar) Reset() { *x = EnvVar{} - mi := &file_ateapi_proto_msgTypes[21] + mi := &file_ateapi_proto_msgTypes[30] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2229,7 +2821,7 @@ func (x *EnvVar) String() string { func (*EnvVar) ProtoMessage() {} func (x *EnvVar) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[21] + mi := &file_ateapi_proto_msgTypes[30] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2242,7 +2834,7 @@ func (x *EnvVar) ProtoReflect() protoreflect.Message { // Deprecated: Use EnvVar.ProtoReflect.Descriptor instead. func (*EnvVar) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{21} + return file_ateapi_proto_rawDescGZIP(), []int{30} } func (x *EnvVar) GetName() string { @@ -2273,7 +2865,7 @@ type ContainerReadyz struct { func (x *ContainerReadyz) Reset() { *x = ContainerReadyz{} - mi := &file_ateapi_proto_msgTypes[22] + mi := &file_ateapi_proto_msgTypes[31] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2285,7 +2877,7 @@ func (x *ContainerReadyz) String() string { func (*ContainerReadyz) ProtoMessage() {} func (x *ContainerReadyz) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[22] + mi := &file_ateapi_proto_msgTypes[31] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2298,7 +2890,7 @@ func (x *ContainerReadyz) ProtoReflect() protoreflect.Message { // Deprecated: Use ContainerReadyz.ProtoReflect.Descriptor instead. func (*ContainerReadyz) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{22} + return file_ateapi_proto_rawDescGZIP(), []int{31} } func (x *ContainerReadyz) GetHttpGet() *HTTPGetAction { @@ -2327,7 +2919,7 @@ type HTTPGetAction struct { func (x *HTTPGetAction) Reset() { *x = HTTPGetAction{} - mi := &file_ateapi_proto_msgTypes[23] + mi := &file_ateapi_proto_msgTypes[32] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2339,7 +2931,7 @@ func (x *HTTPGetAction) String() string { func (*HTTPGetAction) ProtoMessage() {} func (x *HTTPGetAction) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[23] + mi := &file_ateapi_proto_msgTypes[32] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2352,7 +2944,7 @@ func (x *HTTPGetAction) ProtoReflect() protoreflect.Message { // Deprecated: Use HTTPGetAction.ProtoReflect.Descriptor instead. func (*HTTPGetAction) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{23} + return file_ateapi_proto_rawDescGZIP(), []int{32} } func (x *HTTPGetAction) GetPath() string { @@ -2385,7 +2977,7 @@ type Volume struct { func (x *Volume) Reset() { *x = Volume{} - mi := &file_ateapi_proto_msgTypes[24] + mi := &file_ateapi_proto_msgTypes[33] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2397,7 +2989,7 @@ func (x *Volume) String() string { func (*Volume) ProtoMessage() {} func (x *Volume) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[24] + mi := &file_ateapi_proto_msgTypes[33] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2410,7 +3002,7 @@ func (x *Volume) ProtoReflect() protoreflect.Message { // Deprecated: Use Volume.ProtoReflect.Descriptor instead. func (*Volume) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{24} + return file_ateapi_proto_rawDescGZIP(), []int{33} } func (x *Volume) GetName() string { @@ -2451,7 +3043,7 @@ type DurableDirVolumeSource struct { func (x *DurableDirVolumeSource) Reset() { *x = DurableDirVolumeSource{} - mi := &file_ateapi_proto_msgTypes[25] + mi := &file_ateapi_proto_msgTypes[34] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2463,7 +3055,7 @@ func (x *DurableDirVolumeSource) String() string { func (*DurableDirVolumeSource) ProtoMessage() {} func (x *DurableDirVolumeSource) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[25] + mi := &file_ateapi_proto_msgTypes[34] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2476,7 +3068,7 @@ func (x *DurableDirVolumeSource) ProtoReflect() protoreflect.Message { // Deprecated: Use DurableDirVolumeSource.ProtoReflect.Descriptor instead. func (*DurableDirVolumeSource) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{25} + return file_ateapi_proto_rawDescGZIP(), []int{34} } // ExternalVolumeTemplate provisions an external volume per actor; the volume @@ -2495,7 +3087,7 @@ type ExternalVolumeTemplate struct { func (x *ExternalVolumeTemplate) Reset() { *x = ExternalVolumeTemplate{} - mi := &file_ateapi_proto_msgTypes[26] + mi := &file_ateapi_proto_msgTypes[35] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2507,7 +3099,7 @@ func (x *ExternalVolumeTemplate) String() string { func (*ExternalVolumeTemplate) ProtoMessage() {} func (x *ExternalVolumeTemplate) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[26] + mi := &file_ateapi_proto_msgTypes[35] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2520,7 +3112,7 @@ func (x *ExternalVolumeTemplate) ProtoReflect() protoreflect.Message { // Deprecated: Use ExternalVolumeTemplate.ProtoReflect.Descriptor instead. func (*ExternalVolumeTemplate) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{26} + return file_ateapi_proto_rawDescGZIP(), []int{35} } func (x *ExternalVolumeTemplate) GetCapacity() string { @@ -2550,7 +3142,7 @@ type VolumeMount struct { func (x *VolumeMount) Reset() { *x = VolumeMount{} - mi := &file_ateapi_proto_msgTypes[27] + mi := &file_ateapi_proto_msgTypes[36] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2562,7 +3154,7 @@ func (x *VolumeMount) String() string { func (*VolumeMount) ProtoMessage() {} func (x *VolumeMount) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[27] + mi := &file_ateapi_proto_msgTypes[36] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2575,7 +3167,7 @@ func (x *VolumeMount) ProtoReflect() protoreflect.Message { // Deprecated: Use VolumeMount.ProtoReflect.Descriptor instead. func (*VolumeMount) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{27} + return file_ateapi_proto_rawDescGZIP(), []int{36} } func (x *VolumeMount) GetName() string { @@ -2609,7 +3201,7 @@ type SandboxAssets struct { func (x *SandboxAssets) Reset() { *x = SandboxAssets{} - mi := &file_ateapi_proto_msgTypes[28] + mi := &file_ateapi_proto_msgTypes[37] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2621,7 +3213,7 @@ func (x *SandboxAssets) String() string { func (*SandboxAssets) ProtoMessage() {} func (x *SandboxAssets) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[28] + mi := &file_ateapi_proto_msgTypes[37] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2634,7 +3226,7 @@ func (x *SandboxAssets) ProtoReflect() protoreflect.Message { // Deprecated: Use SandboxAssets.ProtoReflect.Descriptor instead. func (*SandboxAssets) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{28} + return file_ateapi_proto_rawDescGZIP(), []int{37} } func (x *SandboxAssets) GetSandboxClass() SandboxClass { @@ -2668,7 +3260,7 @@ type ArchAssets struct { func (x *ArchAssets) Reset() { *x = ArchAssets{} - mi := &file_ateapi_proto_msgTypes[29] + mi := &file_ateapi_proto_msgTypes[38] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2680,7 +3272,7 @@ func (x *ArchAssets) String() string { func (*ArchAssets) ProtoMessage() {} func (x *ArchAssets) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[29] + mi := &file_ateapi_proto_msgTypes[38] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2693,7 +3285,7 @@ func (x *ArchAssets) ProtoReflect() protoreflect.Message { // Deprecated: Use ArchAssets.ProtoReflect.Descriptor instead. func (*ArchAssets) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{29} + return file_ateapi_proto_rawDescGZIP(), []int{38} } func (x *ArchAssets) GetFiles() map[string]*AssetFile { @@ -2717,7 +3309,7 @@ type AssetFile struct { func (x *AssetFile) Reset() { *x = AssetFile{} - mi := &file_ateapi_proto_msgTypes[30] + mi := &file_ateapi_proto_msgTypes[39] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2729,7 +3321,7 @@ func (x *AssetFile) String() string { func (*AssetFile) ProtoMessage() {} func (x *AssetFile) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[30] + mi := &file_ateapi_proto_msgTypes[39] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2742,7 +3334,7 @@ func (x *AssetFile) ProtoReflect() protoreflect.Message { // Deprecated: Use AssetFile.ProtoReflect.Descriptor instead. func (*AssetFile) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{30} + return file_ateapi_proto_rawDescGZIP(), []int{39} } func (x *AssetFile) GetUrl() string { @@ -2771,7 +3363,7 @@ type CreateAtespaceRequest struct { func (x *CreateAtespaceRequest) Reset() { *x = CreateAtespaceRequest{} - mi := &file_ateapi_proto_msgTypes[31] + mi := &file_ateapi_proto_msgTypes[40] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2783,7 +3375,7 @@ func (x *CreateAtespaceRequest) String() string { func (*CreateAtespaceRequest) ProtoMessage() {} func (x *CreateAtespaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[31] + mi := &file_ateapi_proto_msgTypes[40] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2796,7 +3388,7 @@ func (x *CreateAtespaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateAtespaceRequest.ProtoReflect.Descriptor instead. func (*CreateAtespaceRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{31} + return file_ateapi_proto_rawDescGZIP(), []int{40} } func (x *CreateAtespaceRequest) GetAtespace() *Atespace { @@ -2817,7 +3409,7 @@ type GetAtespaceRequest struct { func (x *GetAtespaceRequest) Reset() { *x = GetAtespaceRequest{} - mi := &file_ateapi_proto_msgTypes[32] + mi := &file_ateapi_proto_msgTypes[41] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2829,7 +3421,7 @@ func (x *GetAtespaceRequest) String() string { func (*GetAtespaceRequest) ProtoMessage() {} func (x *GetAtespaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[32] + mi := &file_ateapi_proto_msgTypes[41] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2842,7 +3434,7 @@ func (x *GetAtespaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetAtespaceRequest.ProtoReflect.Descriptor instead. func (*GetAtespaceRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{32} + return file_ateapi_proto_rawDescGZIP(), []int{41} } func (x *GetAtespaceRequest) GetAtespace() *ObjectRef { @@ -2873,7 +3465,7 @@ type ListAtespacesRequest struct { func (x *ListAtespacesRequest) Reset() { *x = ListAtespacesRequest{} - mi := &file_ateapi_proto_msgTypes[33] + mi := &file_ateapi_proto_msgTypes[42] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2885,7 +3477,7 @@ func (x *ListAtespacesRequest) String() string { func (*ListAtespacesRequest) ProtoMessage() {} func (x *ListAtespacesRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[33] + mi := &file_ateapi_proto_msgTypes[42] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2898,7 +3490,7 @@ func (x *ListAtespacesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListAtespacesRequest.ProtoReflect.Descriptor instead. func (*ListAtespacesRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{33} + return file_ateapi_proto_rawDescGZIP(), []int{42} } func (x *ListAtespacesRequest) GetPageSize() int32 { @@ -2927,7 +3519,7 @@ type ListAtespacesResponse struct { func (x *ListAtespacesResponse) Reset() { *x = ListAtespacesResponse{} - mi := &file_ateapi_proto_msgTypes[34] + mi := &file_ateapi_proto_msgTypes[43] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2939,7 +3531,7 @@ func (x *ListAtespacesResponse) String() string { func (*ListAtespacesResponse) ProtoMessage() {} func (x *ListAtespacesResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[34] + mi := &file_ateapi_proto_msgTypes[43] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -2952,7 +3544,7 @@ func (x *ListAtespacesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListAtespacesResponse.ProtoReflect.Descriptor instead. func (*ListAtespacesResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{34} + return file_ateapi_proto_rawDescGZIP(), []int{43} } func (x *ListAtespacesResponse) GetAtespaces() []*Atespace { @@ -2980,7 +3572,7 @@ type DeleteAtespaceRequest struct { func (x *DeleteAtespaceRequest) Reset() { *x = DeleteAtespaceRequest{} - mi := &file_ateapi_proto_msgTypes[35] + mi := &file_ateapi_proto_msgTypes[44] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -2992,7 +3584,7 @@ func (x *DeleteAtespaceRequest) String() string { func (*DeleteAtespaceRequest) ProtoMessage() {} func (x *DeleteAtespaceRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[35] + mi := &file_ateapi_proto_msgTypes[44] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3005,7 +3597,7 @@ func (x *DeleteAtespaceRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteAtespaceRequest.ProtoReflect.Descriptor instead. func (*DeleteAtespaceRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{35} + return file_ateapi_proto_rawDescGZIP(), []int{44} } func (x *DeleteAtespaceRequest) GetAtespace() *ObjectRef { @@ -3027,7 +3619,7 @@ type CreateActorTemplateRequest struct { func (x *CreateActorTemplateRequest) Reset() { *x = CreateActorTemplateRequest{} - mi := &file_ateapi_proto_msgTypes[36] + mi := &file_ateapi_proto_msgTypes[45] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3039,7 +3631,7 @@ func (x *CreateActorTemplateRequest) String() string { func (*CreateActorTemplateRequest) ProtoMessage() {} func (x *CreateActorTemplateRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[36] + mi := &file_ateapi_proto_msgTypes[45] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3052,7 +3644,7 @@ func (x *CreateActorTemplateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateActorTemplateRequest.ProtoReflect.Descriptor instead. func (*CreateActorTemplateRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{36} + return file_ateapi_proto_rawDescGZIP(), []int{45} } func (x *CreateActorTemplateRequest) GetActorTemplate() *ActorTemplate { @@ -3072,7 +3664,7 @@ type GetActorTemplateRequest struct { func (x *GetActorTemplateRequest) Reset() { *x = GetActorTemplateRequest{} - mi := &file_ateapi_proto_msgTypes[37] + mi := &file_ateapi_proto_msgTypes[46] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3084,7 +3676,7 @@ func (x *GetActorTemplateRequest) String() string { func (*GetActorTemplateRequest) ProtoMessage() {} func (x *GetActorTemplateRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[37] + mi := &file_ateapi_proto_msgTypes[46] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3097,7 +3689,7 @@ func (x *GetActorTemplateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetActorTemplateRequest.ProtoReflect.Descriptor instead. func (*GetActorTemplateRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{37} + return file_ateapi_proto_rawDescGZIP(), []int{46} } func (x *GetActorTemplateRequest) GetActorTemplate() *ObjectRef { @@ -3125,7 +3717,7 @@ type ListActorTemplatesRequest struct { func (x *ListActorTemplatesRequest) Reset() { *x = ListActorTemplatesRequest{} - mi := &file_ateapi_proto_msgTypes[38] + mi := &file_ateapi_proto_msgTypes[47] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3137,7 +3729,7 @@ func (x *ListActorTemplatesRequest) String() string { func (*ListActorTemplatesRequest) ProtoMessage() {} func (x *ListActorTemplatesRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[38] + mi := &file_ateapi_proto_msgTypes[47] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3150,7 +3742,7 @@ func (x *ListActorTemplatesRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListActorTemplatesRequest.ProtoReflect.Descriptor instead. func (*ListActorTemplatesRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{38} + return file_ateapi_proto_rawDescGZIP(), []int{47} } func (x *ListActorTemplatesRequest) GetAtespace() string { @@ -3187,7 +3779,7 @@ type ListActorTemplatesResponse struct { func (x *ListActorTemplatesResponse) Reset() { *x = ListActorTemplatesResponse{} - mi := &file_ateapi_proto_msgTypes[39] + mi := &file_ateapi_proto_msgTypes[48] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3199,7 +3791,7 @@ func (x *ListActorTemplatesResponse) String() string { func (*ListActorTemplatesResponse) ProtoMessage() {} func (x *ListActorTemplatesResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[39] + mi := &file_ateapi_proto_msgTypes[48] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3212,7 +3804,7 @@ func (x *ListActorTemplatesResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListActorTemplatesResponse.ProtoReflect.Descriptor instead. func (*ListActorTemplatesResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{39} + return file_ateapi_proto_rawDescGZIP(), []int{48} } func (x *ListActorTemplatesResponse) GetActorTemplates() []*ActorTemplate { @@ -3239,7 +3831,7 @@ type DeleteActorTemplateRequest struct { func (x *DeleteActorTemplateRequest) Reset() { *x = DeleteActorTemplateRequest{} - mi := &file_ateapi_proto_msgTypes[40] + mi := &file_ateapi_proto_msgTypes[49] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3251,7 +3843,7 @@ func (x *DeleteActorTemplateRequest) String() string { func (*DeleteActorTemplateRequest) ProtoMessage() {} func (x *DeleteActorTemplateRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[40] + mi := &file_ateapi_proto_msgTypes[49] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3264,7 +3856,7 @@ func (x *DeleteActorTemplateRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteActorTemplateRequest.ProtoReflect.Descriptor instead. func (*DeleteActorTemplateRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{40} + return file_ateapi_proto_rawDescGZIP(), []int{49} } func (x *DeleteActorTemplateRequest) GetActorTemplate() *ObjectRef { @@ -3284,7 +3876,7 @@ type GetActorRequest struct { func (x *GetActorRequest) Reset() { *x = GetActorRequest{} - mi := &file_ateapi_proto_msgTypes[41] + mi := &file_ateapi_proto_msgTypes[50] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3296,7 +3888,7 @@ func (x *GetActorRequest) String() string { func (*GetActorRequest) ProtoMessage() {} func (x *GetActorRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[41] + mi := &file_ateapi_proto_msgTypes[50] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3309,7 +3901,7 @@ func (x *GetActorRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetActorRequest.ProtoReflect.Descriptor instead. func (*GetActorRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{41} + return file_ateapi_proto_rawDescGZIP(), []int{50} } func (x *GetActorRequest) GetActor() *ObjectRef { @@ -3332,7 +3924,7 @@ type CreateActorRequest struct { func (x *CreateActorRequest) Reset() { *x = CreateActorRequest{} - mi := &file_ateapi_proto_msgTypes[42] + mi := &file_ateapi_proto_msgTypes[51] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3344,7 +3936,7 @@ func (x *CreateActorRequest) String() string { func (*CreateActorRequest) ProtoMessage() {} func (x *CreateActorRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[42] + mi := &file_ateapi_proto_msgTypes[51] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3357,7 +3949,7 @@ func (x *CreateActorRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateActorRequest.ProtoReflect.Descriptor instead. func (*CreateActorRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{42} + return file_ateapi_proto_rawDescGZIP(), []int{51} } func (x *CreateActorRequest) GetActor() *Actor { @@ -3388,7 +3980,7 @@ type UpdateActorRequest struct { func (x *UpdateActorRequest) Reset() { *x = UpdateActorRequest{} - mi := &file_ateapi_proto_msgTypes[43] + mi := &file_ateapi_proto_msgTypes[52] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3400,7 +3992,7 @@ func (x *UpdateActorRequest) String() string { func (*UpdateActorRequest) ProtoMessage() {} func (x *UpdateActorRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[43] + mi := &file_ateapi_proto_msgTypes[52] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3413,7 +4005,7 @@ func (x *UpdateActorRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateActorRequest.ProtoReflect.Descriptor instead. func (*UpdateActorRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{43} + return file_ateapi_proto_rawDescGZIP(), []int{52} } func (x *UpdateActorRequest) GetActor() *Actor { @@ -3433,7 +4025,7 @@ type SuspendActorRequest struct { func (x *SuspendActorRequest) Reset() { *x = SuspendActorRequest{} - mi := &file_ateapi_proto_msgTypes[44] + mi := &file_ateapi_proto_msgTypes[53] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3445,7 +4037,7 @@ func (x *SuspendActorRequest) String() string { func (*SuspendActorRequest) ProtoMessage() {} func (x *SuspendActorRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[44] + mi := &file_ateapi_proto_msgTypes[53] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3458,7 +4050,7 @@ func (x *SuspendActorRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use SuspendActorRequest.ProtoReflect.Descriptor instead. func (*SuspendActorRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{44} + return file_ateapi_proto_rawDescGZIP(), []int{53} } func (x *SuspendActorRequest) GetActor() *ObjectRef { @@ -3477,7 +4069,7 @@ type SuspendActorResponse struct { func (x *SuspendActorResponse) Reset() { *x = SuspendActorResponse{} - mi := &file_ateapi_proto_msgTypes[45] + mi := &file_ateapi_proto_msgTypes[54] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3489,7 +4081,7 @@ func (x *SuspendActorResponse) String() string { func (*SuspendActorResponse) ProtoMessage() {} func (x *SuspendActorResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[45] + mi := &file_ateapi_proto_msgTypes[54] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3502,7 +4094,7 @@ func (x *SuspendActorResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use SuspendActorResponse.ProtoReflect.Descriptor instead. func (*SuspendActorResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{45} + return file_ateapi_proto_rawDescGZIP(), []int{54} } func (x *SuspendActorResponse) GetActor() *Actor { @@ -3522,7 +4114,7 @@ type PauseActorRequest struct { func (x *PauseActorRequest) Reset() { *x = PauseActorRequest{} - mi := &file_ateapi_proto_msgTypes[46] + mi := &file_ateapi_proto_msgTypes[55] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3531,10 +4123,208 @@ func (x *PauseActorRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*PauseActorRequest) ProtoMessage() {} +func (*PauseActorRequest) ProtoMessage() {} + +func (x *PauseActorRequest) ProtoReflect() protoreflect.Message { + mi := &file_ateapi_proto_msgTypes[55] + 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 PauseActorRequest.ProtoReflect.Descriptor instead. +func (*PauseActorRequest) Descriptor() ([]byte, []int) { + return file_ateapi_proto_rawDescGZIP(), []int{55} +} + +func (x *PauseActorRequest) GetActor() *ObjectRef { + if x != nil { + return x.Actor + } + return nil +} + +type PauseActorResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Actor *Actor `protobuf:"bytes,1,opt,name=actor,proto3" json:"actor,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *PauseActorResponse) Reset() { + *x = PauseActorResponse{} + mi := &file_ateapi_proto_msgTypes[56] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *PauseActorResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*PauseActorResponse) ProtoMessage() {} + +func (x *PauseActorResponse) ProtoReflect() protoreflect.Message { + mi := &file_ateapi_proto_msgTypes[56] + 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 PauseActorResponse.ProtoReflect.Descriptor instead. +func (*PauseActorResponse) Descriptor() ([]byte, []int) { + return file_ateapi_proto_rawDescGZIP(), []int{56} +} + +func (x *PauseActorResponse) GetActor() *Actor { + if x != nil { + return x.Actor + } + return nil +} + +type ResumeActorRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // +k8s:opaqueType + Actor *ObjectRef `protobuf:"bytes,1,opt,name=actor,proto3" json:"actor,omitempty"` + // If true, skip golden snapshot and boot the workload from scratch. + Boot bool `protobuf:"varint,2,opt,name=boot,proto3" json:"boot,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResumeActorRequest) Reset() { + *x = ResumeActorRequest{} + mi := &file_ateapi_proto_msgTypes[57] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResumeActorRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResumeActorRequest) ProtoMessage() {} + +func (x *ResumeActorRequest) ProtoReflect() protoreflect.Message { + mi := &file_ateapi_proto_msgTypes[57] + 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 ResumeActorRequest.ProtoReflect.Descriptor instead. +func (*ResumeActorRequest) Descriptor() ([]byte, []int) { + return file_ateapi_proto_rawDescGZIP(), []int{57} +} + +func (x *ResumeActorRequest) GetActor() *ObjectRef { + if x != nil { + return x.Actor + } + return nil +} + +func (x *ResumeActorRequest) GetBoot() bool { + if x != nil { + return x.Boot + } + return false +} + +type ResumeActorResponse struct { + state protoimpl.MessageState `protogen:"open.v1"` + Actor *Actor `protobuf:"bytes,1,opt,name=actor,proto3" json:"actor,omitempty"` + // True if a resume workflow was executed to activate the actor. + // False if the actor was already RUNNING. + Resumed bool `protobuf:"varint,2,opt,name=resumed,proto3" json:"resumed,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *ResumeActorResponse) Reset() { + *x = ResumeActorResponse{} + mi := &file_ateapi_proto_msgTypes[58] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *ResumeActorResponse) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*ResumeActorResponse) ProtoMessage() {} + +func (x *ResumeActorResponse) ProtoReflect() protoreflect.Message { + mi := &file_ateapi_proto_msgTypes[58] + 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 ResumeActorResponse.ProtoReflect.Descriptor instead. +func (*ResumeActorResponse) Descriptor() ([]byte, []int) { + return file_ateapi_proto_rawDescGZIP(), []int{58} +} + +func (x *ResumeActorResponse) GetActor() *Actor { + if x != nil { + return x.Actor + } + return nil +} + +func (x *ResumeActorResponse) GetResumed() bool { + if x != nil { + return x.Resumed + } + return false +} + +type DeleteActorRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // +k8s:opaqueType + Actor *ObjectRef `protobuf:"bytes,1,opt,name=actor,proto3" json:"actor,omitempty"` + AnyState bool `protobuf:"varint,2,opt,name=any_state,json=anyState,proto3" json:"any_state,omitempty"` + unknownFields protoimpl.UnknownFields + sizeCache protoimpl.SizeCache +} + +func (x *DeleteActorRequest) Reset() { + *x = DeleteActorRequest{} + mi := &file_ateapi_proto_msgTypes[59] + ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) + ms.StoreMessageInfo(mi) +} + +func (x *DeleteActorRequest) String() string { + return protoimpl.X.MessageStringOf(x) +} + +func (*DeleteActorRequest) ProtoMessage() {} -func (x *PauseActorRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[46] +func (x *DeleteActorRequest) ProtoReflect() protoreflect.Message { + mi := &file_ateapi_proto_msgTypes[59] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3545,40 +4335,51 @@ func (x *PauseActorRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use PauseActorRequest.ProtoReflect.Descriptor instead. -func (*PauseActorRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{46} +// Deprecated: Use DeleteActorRequest.ProtoReflect.Descriptor instead. +func (*DeleteActorRequest) Descriptor() ([]byte, []int) { + return file_ateapi_proto_rawDescGZIP(), []int{59} } -func (x *PauseActorRequest) GetActor() *ObjectRef { +func (x *DeleteActorRequest) GetActor() *ObjectRef { if x != nil { return x.Actor } return nil } -type PauseActorResponse struct { - state protoimpl.MessageState `protogen:"open.v1"` - Actor *Actor `protobuf:"bytes,1,opt,name=actor,proto3" json:"actor,omitempty"` +func (x *DeleteActorRequest) GetAnyState() bool { + if x != nil { + return x.AnyState + } + return false +} + +type GetActorEgressPolicyRequest struct { + state protoimpl.MessageState `protogen:"open.v1"` + // The parent Actor of the egress policy resource to retrieve. + // + // +k8s:required + // +k8s:subfield(atespace)=+k8s:required + Actor *ObjectRef `protobuf:"bytes,1,opt,name=actor,proto3" json:"actor,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *PauseActorResponse) Reset() { - *x = PauseActorResponse{} - mi := &file_ateapi_proto_msgTypes[47] +func (x *GetActorEgressPolicyRequest) Reset() { + *x = GetActorEgressPolicyRequest{} + mi := &file_ateapi_proto_msgTypes[60] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *PauseActorResponse) String() string { +func (x *GetActorEgressPolicyRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*PauseActorResponse) ProtoMessage() {} +func (*GetActorEgressPolicyRequest) ProtoMessage() {} -func (x *PauseActorResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[47] +func (x *GetActorEgressPolicyRequest) ProtoReflect() protoreflect.Message { + mi := &file_ateapi_proto_msgTypes[60] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3589,43 +4390,50 @@ func (x *PauseActorResponse) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use PauseActorResponse.ProtoReflect.Descriptor instead. -func (*PauseActorResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{47} +// Deprecated: Use GetActorEgressPolicyRequest.ProtoReflect.Descriptor instead. +func (*GetActorEgressPolicyRequest) Descriptor() ([]byte, []int) { + return file_ateapi_proto_rawDescGZIP(), []int{60} } -func (x *PauseActorResponse) GetActor() *Actor { +func (x *GetActorEgressPolicyRequest) GetActor() *ObjectRef { if x != nil { return x.Actor } return nil } -type ResumeActorRequest struct { +// +k8s:customValidation +type CreateActorEgressPolicyRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // +k8s:opaqueType + // Parent Actor under which to create the policy resource. + // + // +k8s:required + // +k8s:subfield(atespace)=+k8s:required Actor *ObjectRef `protobuf:"bytes,1,opt,name=actor,proto3" json:"actor,omitempty"` - // If true, skip golden snapshot and boot the workload from scratch. - Boot bool `protobuf:"varint,2,opt,name=boot,proto3" json:"boot,omitempty"` + // The policy to create. metadata.name must be "default" and + // metadata.atespace must match actor.atespace. + // + // +k8s:required + EgressPolicy *EgressPolicy `protobuf:"bytes,2,opt,name=egress_policy,json=egressPolicy,proto3" json:"egress_policy,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResumeActorRequest) Reset() { - *x = ResumeActorRequest{} - mi := &file_ateapi_proto_msgTypes[48] +func (x *CreateActorEgressPolicyRequest) Reset() { + *x = CreateActorEgressPolicyRequest{} + mi := &file_ateapi_proto_msgTypes[61] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResumeActorRequest) String() string { +func (x *CreateActorEgressPolicyRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResumeActorRequest) ProtoMessage() {} +func (*CreateActorEgressPolicyRequest) ProtoMessage() {} -func (x *ResumeActorRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[48] +func (x *CreateActorEgressPolicyRequest) ProtoReflect() protoreflect.Message { + mi := &file_ateapi_proto_msgTypes[61] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3636,50 +4444,57 @@ func (x *ResumeActorRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ResumeActorRequest.ProtoReflect.Descriptor instead. -func (*ResumeActorRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{48} +// Deprecated: Use CreateActorEgressPolicyRequest.ProtoReflect.Descriptor instead. +func (*CreateActorEgressPolicyRequest) Descriptor() ([]byte, []int) { + return file_ateapi_proto_rawDescGZIP(), []int{61} } -func (x *ResumeActorRequest) GetActor() *ObjectRef { +func (x *CreateActorEgressPolicyRequest) GetActor() *ObjectRef { if x != nil { return x.Actor } return nil } -func (x *ResumeActorRequest) GetBoot() bool { +func (x *CreateActorEgressPolicyRequest) GetEgressPolicy() *EgressPolicy { if x != nil { - return x.Boot + return x.EgressPolicy } - return false + return nil } -type ResumeActorResponse struct { +// +k8s:customValidation +type UpdateActorEgressPolicyRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - Actor *Actor `protobuf:"bytes,1,opt,name=actor,proto3" json:"actor,omitempty"` - // True if a resume workflow was executed to activate the actor. - // False if the actor was already RUNNING. - Resumed bool `protobuf:"varint,2,opt,name=resumed,proto3" json:"resumed,omitempty"` + // Parent Actor under which to update the policy resource. + // + // +k8s:required + // +k8s:subfield(atespace)=+k8s:required + Actor *ObjectRef `protobuf:"bytes,1,opt,name=actor,proto3" json:"actor,omitempty"` + // Full replacement. Metadata UID and version are required preconditions; + // atespace and name are immutable and must match the existing policy. + // + // +k8s:required + EgressPolicy *EgressPolicy `protobuf:"bytes,2,opt,name=egress_policy,json=egressPolicy,proto3" json:"egress_policy,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *ResumeActorResponse) Reset() { - *x = ResumeActorResponse{} - mi := &file_ateapi_proto_msgTypes[49] +func (x *UpdateActorEgressPolicyRequest) Reset() { + *x = UpdateActorEgressPolicyRequest{} + mi := &file_ateapi_proto_msgTypes[62] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *ResumeActorResponse) String() string { +func (x *UpdateActorEgressPolicyRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*ResumeActorResponse) ProtoMessage() {} +func (*UpdateActorEgressPolicyRequest) ProtoMessage() {} -func (x *ResumeActorResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[49] +func (x *UpdateActorEgressPolicyRequest) ProtoReflect() protoreflect.Message { + mi := &file_ateapi_proto_msgTypes[62] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3690,49 +4505,51 @@ func (x *ResumeActorResponse) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use ResumeActorResponse.ProtoReflect.Descriptor instead. -func (*ResumeActorResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{49} +// Deprecated: Use UpdateActorEgressPolicyRequest.ProtoReflect.Descriptor instead. +func (*UpdateActorEgressPolicyRequest) Descriptor() ([]byte, []int) { + return file_ateapi_proto_rawDescGZIP(), []int{62} } -func (x *ResumeActorResponse) GetActor() *Actor { +func (x *UpdateActorEgressPolicyRequest) GetActor() *ObjectRef { if x != nil { return x.Actor } return nil } -func (x *ResumeActorResponse) GetResumed() bool { +func (x *UpdateActorEgressPolicyRequest) GetEgressPolicy() *EgressPolicy { if x != nil { - return x.Resumed + return x.EgressPolicy } - return false + return nil } -type DeleteActorRequest struct { +type DeleteActorEgressPolicyRequest struct { state protoimpl.MessageState `protogen:"open.v1"` - // +k8s:opaqueType + // The parent Actor of the egress policy resource to delete. + // + // +k8s:required + // +k8s:subfield(atespace)=+k8s:required Actor *ObjectRef `protobuf:"bytes,1,opt,name=actor,proto3" json:"actor,omitempty"` - AnyState bool `protobuf:"varint,2,opt,name=any_state,json=anyState,proto3" json:"any_state,omitempty"` unknownFields protoimpl.UnknownFields sizeCache protoimpl.SizeCache } -func (x *DeleteActorRequest) Reset() { - *x = DeleteActorRequest{} - mi := &file_ateapi_proto_msgTypes[50] +func (x *DeleteActorEgressPolicyRequest) Reset() { + *x = DeleteActorEgressPolicyRequest{} + mi := &file_ateapi_proto_msgTypes[63] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } -func (x *DeleteActorRequest) String() string { +func (x *DeleteActorEgressPolicyRequest) String() string { return protoimpl.X.MessageStringOf(x) } -func (*DeleteActorRequest) ProtoMessage() {} +func (*DeleteActorEgressPolicyRequest) ProtoMessage() {} -func (x *DeleteActorRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[50] +func (x *DeleteActorEgressPolicyRequest) ProtoReflect() protoreflect.Message { + mi := &file_ateapi_proto_msgTypes[63] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3743,25 +4560,18 @@ func (x *DeleteActorRequest) ProtoReflect() protoreflect.Message { return mi.MessageOf(x) } -// Deprecated: Use DeleteActorRequest.ProtoReflect.Descriptor instead. -func (*DeleteActorRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{50} +// Deprecated: Use DeleteActorEgressPolicyRequest.ProtoReflect.Descriptor instead. +func (*DeleteActorEgressPolicyRequest) Descriptor() ([]byte, []int) { + return file_ateapi_proto_rawDescGZIP(), []int{63} } -func (x *DeleteActorRequest) GetActor() *ObjectRef { +func (x *DeleteActorEgressPolicyRequest) GetActor() *ObjectRef { if x != nil { return x.Actor } return nil } -func (x *DeleteActorRequest) GetAnyState() bool { - if x != nil { - return x.AnyState - } - return false -} - type GetActorSnapshotRequest struct { state protoimpl.MessageState `protogen:"open.v1"` // +k8s:opaqueType @@ -3772,7 +4582,7 @@ type GetActorSnapshotRequest struct { func (x *GetActorSnapshotRequest) Reset() { *x = GetActorSnapshotRequest{} - mi := &file_ateapi_proto_msgTypes[51] + mi := &file_ateapi_proto_msgTypes[64] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3784,7 +4594,7 @@ func (x *GetActorSnapshotRequest) String() string { func (*GetActorSnapshotRequest) ProtoMessage() {} func (x *GetActorSnapshotRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[51] + mi := &file_ateapi_proto_msgTypes[64] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3797,7 +4607,7 @@ func (x *GetActorSnapshotRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetActorSnapshotRequest.ProtoReflect.Descriptor instead. func (*GetActorSnapshotRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{51} + return file_ateapi_proto_rawDescGZIP(), []int{64} } func (x *GetActorSnapshotRequest) GetActorSnapshot() *ObjectRef { @@ -3817,7 +4627,7 @@ type GetActorSnapshotTagRequest struct { func (x *GetActorSnapshotTagRequest) Reset() { *x = GetActorSnapshotTagRequest{} - mi := &file_ateapi_proto_msgTypes[52] + mi := &file_ateapi_proto_msgTypes[65] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3829,7 +4639,7 @@ func (x *GetActorSnapshotTagRequest) String() string { func (*GetActorSnapshotTagRequest) ProtoMessage() {} func (x *GetActorSnapshotTagRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[52] + mi := &file_ateapi_proto_msgTypes[65] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3842,7 +4652,7 @@ func (x *GetActorSnapshotTagRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetActorSnapshotTagRequest.ProtoReflect.Descriptor instead. func (*GetActorSnapshotTagRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{52} + return file_ateapi_proto_rawDescGZIP(), []int{65} } func (x *GetActorSnapshotTagRequest) GetActorSnapshotTag() *ObjectRef { @@ -3863,7 +4673,7 @@ type ListActorSnapshotsRequest struct { func (x *ListActorSnapshotsRequest) Reset() { *x = ListActorSnapshotsRequest{} - mi := &file_ateapi_proto_msgTypes[53] + mi := &file_ateapi_proto_msgTypes[66] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3875,7 +4685,7 @@ func (x *ListActorSnapshotsRequest) String() string { func (*ListActorSnapshotsRequest) ProtoMessage() {} func (x *ListActorSnapshotsRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[53] + mi := &file_ateapi_proto_msgTypes[66] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3888,7 +4698,7 @@ func (x *ListActorSnapshotsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListActorSnapshotsRequest.ProtoReflect.Descriptor instead. func (*ListActorSnapshotsRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{53} + return file_ateapi_proto_rawDescGZIP(), []int{66} } func (x *ListActorSnapshotsRequest) GetAtespace() string { @@ -3922,7 +4732,7 @@ type ListActorSnapshotsResponse struct { func (x *ListActorSnapshotsResponse) Reset() { *x = ListActorSnapshotsResponse{} - mi := &file_ateapi_proto_msgTypes[54] + mi := &file_ateapi_proto_msgTypes[67] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3934,7 +4744,7 @@ func (x *ListActorSnapshotsResponse) String() string { func (*ListActorSnapshotsResponse) ProtoMessage() {} func (x *ListActorSnapshotsResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[54] + mi := &file_ateapi_proto_msgTypes[67] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3947,7 +4757,7 @@ func (x *ListActorSnapshotsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListActorSnapshotsResponse.ProtoReflect.Descriptor instead. func (*ListActorSnapshotsResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{54} + return file_ateapi_proto_rawDescGZIP(), []int{67} } func (x *ListActorSnapshotsResponse) GetActorSnapshots() []*ActorSnapshot { @@ -3974,7 +4784,7 @@ type CreateActorSnapshotTagRequest struct { func (x *CreateActorSnapshotTagRequest) Reset() { *x = CreateActorSnapshotTagRequest{} - mi := &file_ateapi_proto_msgTypes[55] + mi := &file_ateapi_proto_msgTypes[68] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -3986,7 +4796,7 @@ func (x *CreateActorSnapshotTagRequest) String() string { func (*CreateActorSnapshotTagRequest) ProtoMessage() {} func (x *CreateActorSnapshotTagRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[55] + mi := &file_ateapi_proto_msgTypes[68] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -3999,7 +4809,7 @@ func (x *CreateActorSnapshotTagRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateActorSnapshotTagRequest.ProtoReflect.Descriptor instead. func (*CreateActorSnapshotTagRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{55} + return file_ateapi_proto_rawDescGZIP(), []int{68} } func (x *CreateActorSnapshotTagRequest) GetActorSnapshotTag() *ActorSnapshotTag { @@ -4025,7 +4835,7 @@ type UpdateActorSnapshotTagRequest struct { func (x *UpdateActorSnapshotTagRequest) Reset() { *x = UpdateActorSnapshotTagRequest{} - mi := &file_ateapi_proto_msgTypes[56] + mi := &file_ateapi_proto_msgTypes[69] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4037,7 +4847,7 @@ func (x *UpdateActorSnapshotTagRequest) String() string { func (*UpdateActorSnapshotTagRequest) ProtoMessage() {} func (x *UpdateActorSnapshotTagRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[56] + mi := &file_ateapi_proto_msgTypes[69] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4050,7 +4860,7 @@ func (x *UpdateActorSnapshotTagRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateActorSnapshotTagRequest.ProtoReflect.Descriptor instead. func (*UpdateActorSnapshotTagRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{56} + return file_ateapi_proto_rawDescGZIP(), []int{69} } func (x *UpdateActorSnapshotTagRequest) GetActorSnapshotTag() *ActorSnapshotTag { @@ -4070,7 +4880,7 @@ type DeleteActorSnapshotTagRequest struct { func (x *DeleteActorSnapshotTagRequest) Reset() { *x = DeleteActorSnapshotTagRequest{} - mi := &file_ateapi_proto_msgTypes[57] + mi := &file_ateapi_proto_msgTypes[70] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4082,7 +4892,7 @@ func (x *DeleteActorSnapshotTagRequest) String() string { func (*DeleteActorSnapshotTagRequest) ProtoMessage() {} func (x *DeleteActorSnapshotTagRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[57] + mi := &file_ateapi_proto_msgTypes[70] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4095,7 +4905,7 @@ func (x *DeleteActorSnapshotTagRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteActorSnapshotTagRequest.ProtoReflect.Descriptor instead. func (*DeleteActorSnapshotTagRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{57} + return file_ateapi_proto_rawDescGZIP(), []int{70} } func (x *DeleteActorSnapshotTagRequest) GetActorSnapshotTag() *ObjectRef { @@ -4125,7 +4935,7 @@ type DeleteOptions struct { func (x *DeleteOptions) Reset() { *x = DeleteOptions{} - mi := &file_ateapi_proto_msgTypes[58] + mi := &file_ateapi_proto_msgTypes[71] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4137,7 +4947,7 @@ func (x *DeleteOptions) String() string { func (*DeleteOptions) ProtoMessage() {} func (x *DeleteOptions) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[58] + mi := &file_ateapi_proto_msgTypes[71] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4150,7 +4960,7 @@ func (x *DeleteOptions) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteOptions.ProtoReflect.Descriptor instead. func (*DeleteOptions) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{58} + return file_ateapi_proto_rawDescGZIP(), []int{71} } func (x *DeleteOptions) GetVersion() int64 { @@ -4182,7 +4992,7 @@ type ListWorkersRequest struct { func (x *ListWorkersRequest) Reset() { *x = ListWorkersRequest{} - mi := &file_ateapi_proto_msgTypes[59] + mi := &file_ateapi_proto_msgTypes[72] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4194,7 +5004,7 @@ func (x *ListWorkersRequest) String() string { func (*ListWorkersRequest) ProtoMessage() {} func (x *ListWorkersRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[59] + mi := &file_ateapi_proto_msgTypes[72] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4207,7 +5017,7 @@ func (x *ListWorkersRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkersRequest.ProtoReflect.Descriptor instead. func (*ListWorkersRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{59} + return file_ateapi_proto_rawDescGZIP(), []int{72} } func (x *ListWorkersRequest) GetPageSize() int32 { @@ -4236,7 +5046,7 @@ type ListWorkersResponse struct { func (x *ListWorkersResponse) Reset() { *x = ListWorkersResponse{} - mi := &file_ateapi_proto_msgTypes[60] + mi := &file_ateapi_proto_msgTypes[73] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4248,7 +5058,7 @@ func (x *ListWorkersResponse) String() string { func (*ListWorkersResponse) ProtoMessage() {} func (x *ListWorkersResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[60] + mi := &file_ateapi_proto_msgTypes[73] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4261,7 +5071,7 @@ func (x *ListWorkersResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListWorkersResponse.ProtoReflect.Descriptor instead. func (*ListWorkersResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{60} + return file_ateapi_proto_rawDescGZIP(), []int{73} } func (x *ListWorkersResponse) GetWorkers() []*Worker { @@ -4289,7 +5099,7 @@ type GetWorkerRequest struct { func (x *GetWorkerRequest) Reset() { *x = GetWorkerRequest{} - mi := &file_ateapi_proto_msgTypes[61] + mi := &file_ateapi_proto_msgTypes[74] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4301,7 +5111,7 @@ func (x *GetWorkerRequest) String() string { func (*GetWorkerRequest) ProtoMessage() {} func (x *GetWorkerRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[61] + mi := &file_ateapi_proto_msgTypes[74] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4314,7 +5124,7 @@ func (x *GetWorkerRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use GetWorkerRequest.ProtoReflect.Descriptor instead. func (*GetWorkerRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{61} + return file_ateapi_proto_rawDescGZIP(), []int{74} } func (x *GetWorkerRequest) GetWorker() *ObjectRef { @@ -4334,7 +5144,7 @@ type CreateWorkerRequest struct { func (x *CreateWorkerRequest) Reset() { *x = CreateWorkerRequest{} - mi := &file_ateapi_proto_msgTypes[62] + mi := &file_ateapi_proto_msgTypes[75] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4346,7 +5156,7 @@ func (x *CreateWorkerRequest) String() string { func (*CreateWorkerRequest) ProtoMessage() {} func (x *CreateWorkerRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[62] + mi := &file_ateapi_proto_msgTypes[75] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4359,7 +5169,7 @@ func (x *CreateWorkerRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use CreateWorkerRequest.ProtoReflect.Descriptor instead. func (*CreateWorkerRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{62} + return file_ateapi_proto_rawDescGZIP(), []int{75} } func (x *CreateWorkerRequest) GetWorker() *Worker { @@ -4389,7 +5199,7 @@ type UpdateWorkerRequest struct { func (x *UpdateWorkerRequest) Reset() { *x = UpdateWorkerRequest{} - mi := &file_ateapi_proto_msgTypes[63] + mi := &file_ateapi_proto_msgTypes[76] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4401,7 +5211,7 @@ func (x *UpdateWorkerRequest) String() string { func (*UpdateWorkerRequest) ProtoMessage() {} func (x *UpdateWorkerRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[63] + mi := &file_ateapi_proto_msgTypes[76] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4414,7 +5224,7 @@ func (x *UpdateWorkerRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use UpdateWorkerRequest.ProtoReflect.Descriptor instead. func (*UpdateWorkerRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{63} + return file_ateapi_proto_rawDescGZIP(), []int{76} } func (x *UpdateWorkerRequest) GetWorker() *Worker { @@ -4437,7 +5247,7 @@ type DeleteWorkerRequest struct { func (x *DeleteWorkerRequest) Reset() { *x = DeleteWorkerRequest{} - mi := &file_ateapi_proto_msgTypes[64] + mi := &file_ateapi_proto_msgTypes[77] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4449,7 +5259,7 @@ func (x *DeleteWorkerRequest) String() string { func (*DeleteWorkerRequest) ProtoMessage() {} func (x *DeleteWorkerRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[64] + mi := &file_ateapi_proto_msgTypes[77] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4462,7 +5272,7 @@ func (x *DeleteWorkerRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DeleteWorkerRequest.ProtoReflect.Descriptor instead. func (*DeleteWorkerRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{64} + return file_ateapi_proto_rawDescGZIP(), []int{77} } func (x *DeleteWorkerRequest) GetWorker() *ObjectRef { @@ -4490,7 +5300,7 @@ type DrainWorkerRequest struct { func (x *DrainWorkerRequest) Reset() { *x = DrainWorkerRequest{} - mi := &file_ateapi_proto_msgTypes[65] + mi := &file_ateapi_proto_msgTypes[78] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4502,7 +5312,7 @@ func (x *DrainWorkerRequest) String() string { func (*DrainWorkerRequest) ProtoMessage() {} func (x *DrainWorkerRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[65] + mi := &file_ateapi_proto_msgTypes[78] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4515,7 +5325,7 @@ func (x *DrainWorkerRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DrainWorkerRequest.ProtoReflect.Descriptor instead. func (*DrainWorkerRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{65} + return file_ateapi_proto_rawDescGZIP(), []int{78} } func (x *DrainWorkerRequest) GetWorker() *ObjectRef { @@ -4544,7 +5354,7 @@ type ListActorsRequest struct { func (x *ListActorsRequest) Reset() { *x = ListActorsRequest{} - mi := &file_ateapi_proto_msgTypes[66] + mi := &file_ateapi_proto_msgTypes[79] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4556,7 +5366,7 @@ func (x *ListActorsRequest) String() string { func (*ListActorsRequest) ProtoMessage() {} func (x *ListActorsRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[66] + mi := &file_ateapi_proto_msgTypes[79] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4569,7 +5379,7 @@ func (x *ListActorsRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use ListActorsRequest.ProtoReflect.Descriptor instead. func (*ListActorsRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{66} + return file_ateapi_proto_rawDescGZIP(), []int{79} } func (x *ListActorsRequest) GetAtespace() string { @@ -4605,7 +5415,7 @@ type ListActorsResponse struct { func (x *ListActorsResponse) Reset() { *x = ListActorsResponse{} - mi := &file_ateapi_proto_msgTypes[67] + mi := &file_ateapi_proto_msgTypes[80] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4617,7 +5427,7 @@ func (x *ListActorsResponse) String() string { func (*ListActorsResponse) ProtoMessage() {} func (x *ListActorsResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[67] + mi := &file_ateapi_proto_msgTypes[80] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4630,7 +5440,7 @@ func (x *ListActorsResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use ListActorsResponse.ProtoReflect.Descriptor instead. func (*ListActorsResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{67} + return file_ateapi_proto_rawDescGZIP(), []int{80} } func (x *ListActorsResponse) GetActors() []*Actor { @@ -4686,7 +5496,7 @@ type Worker struct { func (x *Worker) Reset() { *x = Worker{} - mi := &file_ateapi_proto_msgTypes[68] + mi := &file_ateapi_proto_msgTypes[81] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4698,7 +5508,7 @@ func (x *Worker) String() string { func (*Worker) ProtoMessage() {} func (x *Worker) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[68] + mi := &file_ateapi_proto_msgTypes[81] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4711,7 +5521,7 @@ func (x *Worker) ProtoReflect() protoreflect.Message { // Deprecated: Use Worker.ProtoReflect.Descriptor instead. func (*Worker) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{68} + return file_ateapi_proto_rawDescGZIP(), []int{81} } func (x *Worker) GetMetadata() *ResourceMetadata { @@ -4802,7 +5612,7 @@ type WorkerStatus struct { func (x *WorkerStatus) Reset() { *x = WorkerStatus{} - mi := &file_ateapi_proto_msgTypes[69] + mi := &file_ateapi_proto_msgTypes[82] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4814,7 +5624,7 @@ func (x *WorkerStatus) String() string { func (*WorkerStatus) ProtoMessage() {} func (x *WorkerStatus) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[69] + mi := &file_ateapi_proto_msgTypes[82] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4827,7 +5637,7 @@ func (x *WorkerStatus) ProtoReflect() protoreflect.Message { // Deprecated: Use WorkerStatus.ProtoReflect.Descriptor instead. func (*WorkerStatus) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{69} + return file_ateapi_proto_rawDescGZIP(), []int{82} } func (x *WorkerStatus) GetState() WorkerState { @@ -4860,7 +5670,7 @@ type WorkerCapacity struct { func (x *WorkerCapacity) Reset() { *x = WorkerCapacity{} - mi := &file_ateapi_proto_msgTypes[70] + mi := &file_ateapi_proto_msgTypes[83] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4872,7 +5682,7 @@ func (x *WorkerCapacity) String() string { func (*WorkerCapacity) ProtoMessage() {} func (x *WorkerCapacity) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[70] + mi := &file_ateapi_proto_msgTypes[83] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4885,7 +5695,7 @@ func (x *WorkerCapacity) ProtoReflect() protoreflect.Message { // Deprecated: Use WorkerCapacity.ProtoReflect.Descriptor instead. func (*WorkerCapacity) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{70} + return file_ateapi_proto_rawDescGZIP(), []int{83} } func (x *WorkerCapacity) GetCpuMilli() int64 { @@ -4918,7 +5728,7 @@ type ActorAssignment struct { func (x *ActorAssignment) Reset() { *x = ActorAssignment{} - mi := &file_ateapi_proto_msgTypes[71] + mi := &file_ateapi_proto_msgTypes[84] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4930,7 +5740,7 @@ func (x *ActorAssignment) String() string { func (*ActorAssignment) ProtoMessage() {} func (x *ActorAssignment) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[71] + mi := &file_ateapi_proto_msgTypes[84] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -4943,7 +5753,7 @@ func (x *ActorAssignment) ProtoReflect() protoreflect.Message { // Deprecated: Use ActorAssignment.ProtoReflect.Descriptor instead. func (*ActorAssignment) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{71} + return file_ateapi_proto_rawDescGZIP(), []int{84} } func (x *ActorAssignment) GetActorTemplate() *KubeNamespacedObjectRef { @@ -4977,7 +5787,7 @@ type KubeNamespacedObjectRef struct { func (x *KubeNamespacedObjectRef) Reset() { *x = KubeNamespacedObjectRef{} - mi := &file_ateapi_proto_msgTypes[72] + mi := &file_ateapi_proto_msgTypes[85] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -4989,7 +5799,7 @@ func (x *KubeNamespacedObjectRef) String() string { func (*KubeNamespacedObjectRef) ProtoMessage() {} func (x *KubeNamespacedObjectRef) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[72] + mi := &file_ateapi_proto_msgTypes[85] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5002,7 +5812,7 @@ func (x *KubeNamespacedObjectRef) ProtoReflect() protoreflect.Message { // Deprecated: Use KubeNamespacedObjectRef.ProtoReflect.Descriptor instead. func (*KubeNamespacedObjectRef) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{72} + return file_ateapi_proto_rawDescGZIP(), []int{85} } func (x *KubeNamespacedObjectRef) GetNamespace() string { @@ -5027,7 +5837,7 @@ type DebugClearRequest struct { func (x *DebugClearRequest) Reset() { *x = DebugClearRequest{} - mi := &file_ateapi_proto_msgTypes[73] + mi := &file_ateapi_proto_msgTypes[86] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5039,7 +5849,7 @@ func (x *DebugClearRequest) String() string { func (*DebugClearRequest) ProtoMessage() {} func (x *DebugClearRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[73] + mi := &file_ateapi_proto_msgTypes[86] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5052,7 +5862,7 @@ func (x *DebugClearRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use DebugClearRequest.ProtoReflect.Descriptor instead. func (*DebugClearRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{73} + return file_ateapi_proto_rawDescGZIP(), []int{86} } type DebugClearResponse struct { @@ -5063,7 +5873,7 @@ type DebugClearResponse struct { func (x *DebugClearResponse) Reset() { *x = DebugClearResponse{} - mi := &file_ateapi_proto_msgTypes[74] + mi := &file_ateapi_proto_msgTypes[87] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5075,7 +5885,7 @@ func (x *DebugClearResponse) String() string { func (*DebugClearResponse) ProtoMessage() {} func (x *DebugClearResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[74] + mi := &file_ateapi_proto_msgTypes[87] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5088,7 +5898,7 @@ func (x *DebugClearResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use DebugClearResponse.ProtoReflect.Descriptor instead. func (*DebugClearResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{74} + return file_ateapi_proto_rawDescGZIP(), []int{87} } type MintJWTRequest struct { @@ -5103,7 +5913,7 @@ type MintJWTRequest struct { func (x *MintJWTRequest) Reset() { *x = MintJWTRequest{} - mi := &file_ateapi_proto_msgTypes[75] + mi := &file_ateapi_proto_msgTypes[88] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5115,7 +5925,7 @@ func (x *MintJWTRequest) String() string { func (*MintJWTRequest) ProtoMessage() {} func (x *MintJWTRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[75] + mi := &file_ateapi_proto_msgTypes[88] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5128,7 +5938,7 @@ func (x *MintJWTRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MintJWTRequest.ProtoReflect.Descriptor instead. func (*MintJWTRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{75} + return file_ateapi_proto_rawDescGZIP(), []int{88} } func (x *MintJWTRequest) GetAudience() []string { @@ -5189,7 +5999,7 @@ type MintJWTResponse struct { func (x *MintJWTResponse) Reset() { *x = MintJWTResponse{} - mi := &file_ateapi_proto_msgTypes[76] + mi := &file_ateapi_proto_msgTypes[89] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5201,7 +6011,7 @@ func (x *MintJWTResponse) String() string { func (*MintJWTResponse) ProtoMessage() {} func (x *MintJWTResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[76] + mi := &file_ateapi_proto_msgTypes[89] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5214,7 +6024,7 @@ func (x *MintJWTResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MintJWTResponse.ProtoReflect.Descriptor instead. func (*MintJWTResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{76} + return file_ateapi_proto_rawDescGZIP(), []int{89} } func (x *MintJWTResponse) GetActorJwt() string { @@ -5250,7 +6060,7 @@ type MintCertRequest struct { func (x *MintCertRequest) Reset() { *x = MintCertRequest{} - mi := &file_ateapi_proto_msgTypes[77] + mi := &file_ateapi_proto_msgTypes[90] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5262,7 +6072,7 @@ func (x *MintCertRequest) String() string { func (*MintCertRequest) ProtoMessage() {} func (x *MintCertRequest) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[77] + mi := &file_ateapi_proto_msgTypes[90] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5275,7 +6085,7 @@ func (x *MintCertRequest) ProtoReflect() protoreflect.Message { // Deprecated: Use MintCertRequest.ProtoReflect.Descriptor instead. func (*MintCertRequest) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{77} + return file_ateapi_proto_rawDescGZIP(), []int{90} } func (x *MintCertRequest) GetWorker() *ObjectRef { @@ -5318,7 +6128,7 @@ type MintCertResponse struct { func (x *MintCertResponse) Reset() { *x = MintCertResponse{} - mi := &file_ateapi_proto_msgTypes[78] + mi := &file_ateapi_proto_msgTypes[91] ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) ms.StoreMessageInfo(mi) } @@ -5330,7 +6140,7 @@ func (x *MintCertResponse) String() string { func (*MintCertResponse) ProtoMessage() {} func (x *MintCertResponse) ProtoReflect() protoreflect.Message { - mi := &file_ateapi_proto_msgTypes[78] + mi := &file_ateapi_proto_msgTypes[91] if x != nil { ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x)) if ms.LoadMessageInfo() == nil { @@ -5343,7 +6153,7 @@ func (x *MintCertResponse) ProtoReflect() protoreflect.Message { // Deprecated: Use MintCertResponse.ProtoReflect.Descriptor instead. func (*MintCertResponse) Descriptor() ([]byte, []int) { - return file_ateapi_proto_rawDescGZIP(), []int{78} + return file_ateapi_proto_rawDescGZIP(), []int{91} } func (x *MintCertResponse) GetActorCertificates() [][]byte { @@ -5357,7 +6167,7 @@ var File_ateapi_proto protoreflect.FileDescriptor const file_ateapi_proto_rawDesc = "" + "\n" + - "\fateapi.proto\x12\x06ateapi\x1a\x1fgoogle/protobuf/timestamp.proto\"\xbd\x01\n" + + "\fateapi.proto\x12\x06ateapi\x1a\x1bgoogle/protobuf/empty.proto\x1a\x1fgoogle/protobuf/timestamp.proto\"\xbd\x01\n" + "\x11LocalSnapshotInfo\x12#\n" + "\rsnapshot_name\x18\x01 \x01(\tR\fsnapshotName\x12@\n" + "\x1dnode_vms_with_local_snapshots\x18\x02 \x03(\tR\x19nodeVmsWithLocalSnapshots\x12A\n" + @@ -5399,7 +6209,39 @@ const file_ateapi_proto_rawDesc = "" + "\x0eactor_template\x18\x04 \x01(\v2\x11.ateapi.ObjectRefR\ractorTemplate\x129\n" + "\x0fworker_selector\x18\x05 \x01(\v2\x10.ateapi.SelectorR\x0eworkerSelector\x12A\n" + "\x13source_snapshot_tag\x18\x06 \x01(\v2\x11.ateapi.ObjectRefR\x11sourceSnapshotTag\x12+\n" + - "\x06status\x18\a \x01(\v2\x13.ateapi.ActorStatusR\x06status\"\xe8\x04\n" + + "\x06status\x18\a \x01(\v2\x13.ateapi.ActorStatusR\x06status\"n\n" + + "\fEgressPolicy\x124\n" + + "\bmetadata\x18\x01 \x01(\v2\x18.ateapi.ResourceMetadataR\bmetadata\x12(\n" + + "\x05rules\x18\x02 \x03(\v2\x12.ateapi.EgressRuleR\x05rules\"l\n" + + "\n" + + "EgressRule\x12)\n" + + "\x05allow\x18\x01 \x03(\v2\x13.ateapi.EgressMatchR\x05allow\x123\n" + + "\aeffects\x18\x02 \x01(\v2\x19.ateapi.EgressRuleEffectsR\aeffects\"\x9b\x01\n" + + "\vEgressMatch\x12(\n" + + "\x03all\x18\x01 \x01(\v2\x16.google.protobuf.EmptyR\x03all\x121\n" + + "\bhostname\x18\x02 \x01(\v2\x15.ateapi.HostnameMatchR\bhostname\x12/\n" + + "\bip_block\x18\x03 \x01(\v2\x14.ateapi.IPBlockMatchR\aipBlock\")\n" + + "\rHostnameMatch\x12\x18\n" + + "\apattern\x18\x01 \x01(\tR\apattern\"\"\n" + + "\fIPBlockMatch\x12\x12\n" + + "\x04cidr\x18\x01 \x01(\tR\x04cidr\"\xab\x01\n" + + "\x11EgressRuleEffects\x12O\n" + + "\x14inject_static_header\x18\x01 \x03(\v2\x1d.ateapi.StaticHeaderInjectionR\x12injectStaticHeader\x12E\n" + + "\x10inject_actor_jwt\x18\x02 \x01(\v2\x1b.ateapi.ActorTokenInjectionR\x0einjectActorJwt\"n\n" + + "\x15StaticHeaderInjection\x12\x16\n" + + "\x06header\x18\x01 \x01(\tR\x06header\x12\x16\n" + + "\x06prefix\x18\x02 \x01(\tR\x06prefix\x12%\n" + + "\x0ecredential_uri\x18\x03 \x01(\tR\rcredentialUri\"\x9a\x01\n" + + "\x13ActorTokenInjection\x12\x16\n" + + "\x06header\x18\x01 \x01(\tR\x06header\x12\x1c\n" + + "\taudiences\x18\x02 \x03(\tR\taudiences\x12M\n" + + "\x11rfc_8693_exchange\x18\x03 \x01(\v2!.ateapi.RFC8693ExchangeParametersR\x0frfc8693Exchange\"\xb1\x01\n" + + "\x19RFC8693ExchangeParameters\x12\x10\n" + + "\x03url\x18\x01 \x01(\tR\x03url\x12\x1c\n" + + "\tresources\x18\x02 \x03(\tR\tresources\x12\x1c\n" + + "\taudiences\x18\x03 \x03(\tR\taudiences\x12\x14\n" + + "\x05scope\x18\x04 \x01(\tR\x05scope\x120\n" + + "\x14requested_token_type\x18\x05 \x01(\tR\x12requestedTokenType\"\xe8\x04\n" + "\vActorStatus\x12(\n" + "\x05state\x18\x01 \x01(\x0e2\x12.ateapi.ActorStateR\x05state\x12E\n" + "\x11worker_assignment\x18\x02 \x01(\v2\x18.ateapi.WorkerAssignmentR\x10workerAssignment\x129\n" + @@ -5574,7 +6416,17 @@ const file_ateapi_proto_rawDesc = "" + "\aresumed\x18\x02 \x01(\bR\aresumed\"Z\n" + "\x12DeleteActorRequest\x12'\n" + "\x05actor\x18\x01 \x01(\v2\x11.ateapi.ObjectRefR\x05actor\x12\x1b\n" + - "\tany_state\x18\x02 \x01(\bR\banyState\"S\n" + + "\tany_state\x18\x02 \x01(\bR\banyState\"F\n" + + "\x1bGetActorEgressPolicyRequest\x12'\n" + + "\x05actor\x18\x01 \x01(\v2\x11.ateapi.ObjectRefR\x05actor\"\x84\x01\n" + + "\x1eCreateActorEgressPolicyRequest\x12'\n" + + "\x05actor\x18\x01 \x01(\v2\x11.ateapi.ObjectRefR\x05actor\x129\n" + + "\regress_policy\x18\x02 \x01(\v2\x14.ateapi.EgressPolicyR\fegressPolicy\"\x84\x01\n" + + "\x1eUpdateActorEgressPolicyRequest\x12'\n" + + "\x05actor\x18\x01 \x01(\v2\x11.ateapi.ObjectRefR\x05actor\x129\n" + + "\regress_policy\x18\x02 \x01(\v2\x14.ateapi.EgressPolicyR\fegressPolicy\"I\n" + + "\x1eDeleteActorEgressPolicyRequest\x12'\n" + + "\x05actor\x18\x01 \x01(\v2\x11.ateapi.ObjectRefR\x05actor\"S\n" + "\x17GetActorSnapshotRequest\x128\n" + "\x0eactor_snapshot\x18\x01 \x01(\v2\x11.ateapi.ObjectRefR\ractorSnapshot\"]\n" + "\x1aGetActorSnapshotTagRequest\x12?\n" + @@ -5712,7 +6564,7 @@ const file_ateapi_proto_rawDesc = "" + "\x15WORKER_STATE_DRAINING\x10\x02*k\n" + "\x17ActorCertificatePurpose\x12)\n" + "%ACTOR_CERTIFICATE_PURPOSE_UNSPECIFIED\x10\x00\x12%\n" + - "!ACTOR_CERTIFICATE_PURPOSE_ATUNNEL\x10\x012\x9e\x10\n" + + "!ACTOR_CERTIFICATE_PURPOSE_ATUNNEL\x10\x012\x84\x13\n" + "\aControl\x124\n" + "\bGetActor\x12\x17.ateapi.GetActorRequest\x1a\r.ateapi.Actor\"\x00\x12:\n" + "\vCreateActor\x12\x1a.ateapi.CreateActorRequest\x1a\r.ateapi.Actor\"\x00\x12:\n" + @@ -5721,7 +6573,11 @@ const file_ateapi_proto_rawDesc = "" + "\n" + "PauseActor\x12\x19.ateapi.PauseActorRequest\x1a\x1a.ateapi.PauseActorResponse\"\x00\x12H\n" + "\vResumeActor\x12\x1a.ateapi.ResumeActorRequest\x1a\x1b.ateapi.ResumeActorResponse\"\x00\x12:\n" + - "\vDeleteActor\x12\x1a.ateapi.DeleteActorRequest\x1a\r.ateapi.Actor\"\x00\x12L\n" + + "\vDeleteActor\x12\x1a.ateapi.DeleteActorRequest\x1a\r.ateapi.Actor\"\x00\x12S\n" + + "\x14GetActorEgressPolicy\x12#.ateapi.GetActorEgressPolicyRequest\x1a\x14.ateapi.EgressPolicy\"\x00\x12Y\n" + + "\x17CreateActorEgressPolicy\x12&.ateapi.CreateActorEgressPolicyRequest\x1a\x14.ateapi.EgressPolicy\"\x00\x12Y\n" + + "\x17UpdateActorEgressPolicy\x12&.ateapi.UpdateActorEgressPolicyRequest\x1a\x14.ateapi.EgressPolicy\"\x00\x12Y\n" + + "\x17DeleteActorEgressPolicy\x12&.ateapi.DeleteActorEgressPolicyRequest\x1a\x14.ateapi.EgressPolicy\"\x00\x12L\n" + "\x10GetActorSnapshot\x12\x1f.ateapi.GetActorSnapshotRequest\x1a\x15.ateapi.ActorSnapshot\"\x00\x12U\n" + "\x13GetActorSnapshotTag\x12\".ateapi.GetActorSnapshotTagRequest\x1a\x18.ateapi.ActorSnapshotTag\"\x00\x12]\n" + "\x12ListActorSnapshots\x12!.ateapi.ListActorSnapshotsRequest\x1a\".ateapi.ListActorSnapshotsResponse\"\x00\x12[\n" + @@ -5764,269 +6620,307 @@ func file_ateapi_proto_rawDescGZIP() []byte { } var file_ateapi_proto_enumTypes = make([]protoimpl.EnumInfo, 9) -var file_ateapi_proto_msgTypes = make([]protoimpl.MessageInfo, 84) +var file_ateapi_proto_msgTypes = make([]protoimpl.MessageInfo, 97) var file_ateapi_proto_goTypes = []any{ - (SnapshotContentScope)(0), // 0: ateapi.SnapshotContentScope - (ActorSnapshotTagScope)(0), // 1: ateapi.ActorSnapshotTagScope - (ActorState)(0), // 2: ateapi.ActorState - (SandboxClass)(0), // 3: ateapi.SandboxClass - (ActorTemplatePhase)(0), // 4: ateapi.ActorTemplatePhase - (ResumeSource)(0), // 5: ateapi.ResumeSource - (WorkerState)(0), // 6: ateapi.WorkerState - (ActorCertificatePurpose)(0), // 7: ateapi.ActorCertificatePurpose - (ExternalVolume_Status)(0), // 8: ateapi.ExternalVolume.Status - (*LocalSnapshotInfo)(nil), // 9: ateapi.LocalSnapshotInfo - (*Selector)(nil), // 10: ateapi.Selector - (*ResourceMetadata)(nil), // 11: ateapi.ResourceMetadata - (*ExternalVolume)(nil), // 12: ateapi.ExternalVolume - (*Actor)(nil), // 13: ateapi.Actor - (*ActorStatus)(nil), // 14: ateapi.ActorStatus - (*ActorSourceSnapshotStatus)(nil), // 15: ateapi.ActorSourceSnapshotStatus - (*WorkerAssignment)(nil), // 16: ateapi.WorkerAssignment - (*ActorSnapshot)(nil), // 17: ateapi.ActorSnapshot - (*ActorSnapshotStatus)(nil), // 18: ateapi.ActorSnapshotStatus - (*ActorSnapshotTag)(nil), // 19: ateapi.ActorSnapshotTag - (*Atespace)(nil), // 20: ateapi.Atespace - (*ObjectRef)(nil), // 21: ateapi.ObjectRef - (*ActorTemplate)(nil), // 22: ateapi.ActorTemplate - (*Resources)(nil), // 23: ateapi.Resources - (*Limits)(nil), // 24: ateapi.Limits - (*ActorTemplateStatus)(nil), // 25: ateapi.ActorTemplateStatus - (*SandboxConfig)(nil), // 26: ateapi.SandboxConfig - (*SnapshotsConfig)(nil), // 27: ateapi.SnapshotsConfig - (*OnResumeConfig)(nil), // 28: ateapi.OnResumeConfig - (*Container)(nil), // 29: ateapi.Container - (*EnvVar)(nil), // 30: ateapi.EnvVar - (*ContainerReadyz)(nil), // 31: ateapi.ContainerReadyz - (*HTTPGetAction)(nil), // 32: ateapi.HTTPGetAction - (*Volume)(nil), // 33: ateapi.Volume - (*DurableDirVolumeSource)(nil), // 34: ateapi.DurableDirVolumeSource - (*ExternalVolumeTemplate)(nil), // 35: ateapi.ExternalVolumeTemplate - (*VolumeMount)(nil), // 36: ateapi.VolumeMount - (*SandboxAssets)(nil), // 37: ateapi.SandboxAssets - (*ArchAssets)(nil), // 38: ateapi.ArchAssets - (*AssetFile)(nil), // 39: ateapi.AssetFile - (*CreateAtespaceRequest)(nil), // 40: ateapi.CreateAtespaceRequest - (*GetAtespaceRequest)(nil), // 41: ateapi.GetAtespaceRequest - (*ListAtespacesRequest)(nil), // 42: ateapi.ListAtespacesRequest - (*ListAtespacesResponse)(nil), // 43: ateapi.ListAtespacesResponse - (*DeleteAtespaceRequest)(nil), // 44: ateapi.DeleteAtespaceRequest - (*CreateActorTemplateRequest)(nil), // 45: ateapi.CreateActorTemplateRequest - (*GetActorTemplateRequest)(nil), // 46: ateapi.GetActorTemplateRequest - (*ListActorTemplatesRequest)(nil), // 47: ateapi.ListActorTemplatesRequest - (*ListActorTemplatesResponse)(nil), // 48: ateapi.ListActorTemplatesResponse - (*DeleteActorTemplateRequest)(nil), // 49: ateapi.DeleteActorTemplateRequest - (*GetActorRequest)(nil), // 50: ateapi.GetActorRequest - (*CreateActorRequest)(nil), // 51: ateapi.CreateActorRequest - (*UpdateActorRequest)(nil), // 52: ateapi.UpdateActorRequest - (*SuspendActorRequest)(nil), // 53: ateapi.SuspendActorRequest - (*SuspendActorResponse)(nil), // 54: ateapi.SuspendActorResponse - (*PauseActorRequest)(nil), // 55: ateapi.PauseActorRequest - (*PauseActorResponse)(nil), // 56: ateapi.PauseActorResponse - (*ResumeActorRequest)(nil), // 57: ateapi.ResumeActorRequest - (*ResumeActorResponse)(nil), // 58: ateapi.ResumeActorResponse - (*DeleteActorRequest)(nil), // 59: ateapi.DeleteActorRequest - (*GetActorSnapshotRequest)(nil), // 60: ateapi.GetActorSnapshotRequest - (*GetActorSnapshotTagRequest)(nil), // 61: ateapi.GetActorSnapshotTagRequest - (*ListActorSnapshotsRequest)(nil), // 62: ateapi.ListActorSnapshotsRequest - (*ListActorSnapshotsResponse)(nil), // 63: ateapi.ListActorSnapshotsResponse - (*CreateActorSnapshotTagRequest)(nil), // 64: ateapi.CreateActorSnapshotTagRequest - (*UpdateActorSnapshotTagRequest)(nil), // 65: ateapi.UpdateActorSnapshotTagRequest - (*DeleteActorSnapshotTagRequest)(nil), // 66: ateapi.DeleteActorSnapshotTagRequest - (*DeleteOptions)(nil), // 67: ateapi.DeleteOptions - (*ListWorkersRequest)(nil), // 68: ateapi.ListWorkersRequest - (*ListWorkersResponse)(nil), // 69: ateapi.ListWorkersResponse - (*GetWorkerRequest)(nil), // 70: ateapi.GetWorkerRequest - (*CreateWorkerRequest)(nil), // 71: ateapi.CreateWorkerRequest - (*UpdateWorkerRequest)(nil), // 72: ateapi.UpdateWorkerRequest - (*DeleteWorkerRequest)(nil), // 73: ateapi.DeleteWorkerRequest - (*DrainWorkerRequest)(nil), // 74: ateapi.DrainWorkerRequest - (*ListActorsRequest)(nil), // 75: ateapi.ListActorsRequest - (*ListActorsResponse)(nil), // 76: ateapi.ListActorsResponse - (*Worker)(nil), // 77: ateapi.Worker - (*WorkerStatus)(nil), // 78: ateapi.WorkerStatus - (*WorkerCapacity)(nil), // 79: ateapi.WorkerCapacity - (*ActorAssignment)(nil), // 80: ateapi.ActorAssignment - (*KubeNamespacedObjectRef)(nil), // 81: ateapi.KubeNamespacedObjectRef - (*DebugClearRequest)(nil), // 82: ateapi.DebugClearRequest - (*DebugClearResponse)(nil), // 83: ateapi.DebugClearResponse - (*MintJWTRequest)(nil), // 84: ateapi.MintJWTRequest - (*MintJWTResponse)(nil), // 85: ateapi.MintJWTResponse - (*MintCertRequest)(nil), // 86: ateapi.MintCertRequest - (*MintCertResponse)(nil), // 87: ateapi.MintCertResponse - nil, // 88: ateapi.Selector.MatchLabelsEntry - nil, // 89: ateapi.ExternalVolume.VolumeContextEntry - nil, // 90: ateapi.SandboxAssets.AssetsEntry - nil, // 91: ateapi.ArchAssets.FilesEntry - nil, // 92: ateapi.Worker.LabelsEntry - (*timestamppb.Timestamp)(nil), // 93: google.protobuf.Timestamp + (SnapshotContentScope)(0), // 0: ateapi.SnapshotContentScope + (ActorSnapshotTagScope)(0), // 1: ateapi.ActorSnapshotTagScope + (ActorState)(0), // 2: ateapi.ActorState + (SandboxClass)(0), // 3: ateapi.SandboxClass + (ActorTemplatePhase)(0), // 4: ateapi.ActorTemplatePhase + (ResumeSource)(0), // 5: ateapi.ResumeSource + (WorkerState)(0), // 6: ateapi.WorkerState + (ActorCertificatePurpose)(0), // 7: ateapi.ActorCertificatePurpose + (ExternalVolume_Status)(0), // 8: ateapi.ExternalVolume.Status + (*LocalSnapshotInfo)(nil), // 9: ateapi.LocalSnapshotInfo + (*Selector)(nil), // 10: ateapi.Selector + (*ResourceMetadata)(nil), // 11: ateapi.ResourceMetadata + (*ExternalVolume)(nil), // 12: ateapi.ExternalVolume + (*Actor)(nil), // 13: ateapi.Actor + (*EgressPolicy)(nil), // 14: ateapi.EgressPolicy + (*EgressRule)(nil), // 15: ateapi.EgressRule + (*EgressMatch)(nil), // 16: ateapi.EgressMatch + (*HostnameMatch)(nil), // 17: ateapi.HostnameMatch + (*IPBlockMatch)(nil), // 18: ateapi.IPBlockMatch + (*EgressRuleEffects)(nil), // 19: ateapi.EgressRuleEffects + (*StaticHeaderInjection)(nil), // 20: ateapi.StaticHeaderInjection + (*ActorTokenInjection)(nil), // 21: ateapi.ActorTokenInjection + (*RFC8693ExchangeParameters)(nil), // 22: ateapi.RFC8693ExchangeParameters + (*ActorStatus)(nil), // 23: ateapi.ActorStatus + (*ActorSourceSnapshotStatus)(nil), // 24: ateapi.ActorSourceSnapshotStatus + (*WorkerAssignment)(nil), // 25: ateapi.WorkerAssignment + (*ActorSnapshot)(nil), // 26: ateapi.ActorSnapshot + (*ActorSnapshotStatus)(nil), // 27: ateapi.ActorSnapshotStatus + (*ActorSnapshotTag)(nil), // 28: ateapi.ActorSnapshotTag + (*Atespace)(nil), // 29: ateapi.Atespace + (*ObjectRef)(nil), // 30: ateapi.ObjectRef + (*ActorTemplate)(nil), // 31: ateapi.ActorTemplate + (*Resources)(nil), // 32: ateapi.Resources + (*Limits)(nil), // 33: ateapi.Limits + (*ActorTemplateStatus)(nil), // 34: ateapi.ActorTemplateStatus + (*SandboxConfig)(nil), // 35: ateapi.SandboxConfig + (*SnapshotsConfig)(nil), // 36: ateapi.SnapshotsConfig + (*OnResumeConfig)(nil), // 37: ateapi.OnResumeConfig + (*Container)(nil), // 38: ateapi.Container + (*EnvVar)(nil), // 39: ateapi.EnvVar + (*ContainerReadyz)(nil), // 40: ateapi.ContainerReadyz + (*HTTPGetAction)(nil), // 41: ateapi.HTTPGetAction + (*Volume)(nil), // 42: ateapi.Volume + (*DurableDirVolumeSource)(nil), // 43: ateapi.DurableDirVolumeSource + (*ExternalVolumeTemplate)(nil), // 44: ateapi.ExternalVolumeTemplate + (*VolumeMount)(nil), // 45: ateapi.VolumeMount + (*SandboxAssets)(nil), // 46: ateapi.SandboxAssets + (*ArchAssets)(nil), // 47: ateapi.ArchAssets + (*AssetFile)(nil), // 48: ateapi.AssetFile + (*CreateAtespaceRequest)(nil), // 49: ateapi.CreateAtespaceRequest + (*GetAtespaceRequest)(nil), // 50: ateapi.GetAtespaceRequest + (*ListAtespacesRequest)(nil), // 51: ateapi.ListAtespacesRequest + (*ListAtespacesResponse)(nil), // 52: ateapi.ListAtespacesResponse + (*DeleteAtespaceRequest)(nil), // 53: ateapi.DeleteAtespaceRequest + (*CreateActorTemplateRequest)(nil), // 54: ateapi.CreateActorTemplateRequest + (*GetActorTemplateRequest)(nil), // 55: ateapi.GetActorTemplateRequest + (*ListActorTemplatesRequest)(nil), // 56: ateapi.ListActorTemplatesRequest + (*ListActorTemplatesResponse)(nil), // 57: ateapi.ListActorTemplatesResponse + (*DeleteActorTemplateRequest)(nil), // 58: ateapi.DeleteActorTemplateRequest + (*GetActorRequest)(nil), // 59: ateapi.GetActorRequest + (*CreateActorRequest)(nil), // 60: ateapi.CreateActorRequest + (*UpdateActorRequest)(nil), // 61: ateapi.UpdateActorRequest + (*SuspendActorRequest)(nil), // 62: ateapi.SuspendActorRequest + (*SuspendActorResponse)(nil), // 63: ateapi.SuspendActorResponse + (*PauseActorRequest)(nil), // 64: ateapi.PauseActorRequest + (*PauseActorResponse)(nil), // 65: ateapi.PauseActorResponse + (*ResumeActorRequest)(nil), // 66: ateapi.ResumeActorRequest + (*ResumeActorResponse)(nil), // 67: ateapi.ResumeActorResponse + (*DeleteActorRequest)(nil), // 68: ateapi.DeleteActorRequest + (*GetActorEgressPolicyRequest)(nil), // 69: ateapi.GetActorEgressPolicyRequest + (*CreateActorEgressPolicyRequest)(nil), // 70: ateapi.CreateActorEgressPolicyRequest + (*UpdateActorEgressPolicyRequest)(nil), // 71: ateapi.UpdateActorEgressPolicyRequest + (*DeleteActorEgressPolicyRequest)(nil), // 72: ateapi.DeleteActorEgressPolicyRequest + (*GetActorSnapshotRequest)(nil), // 73: ateapi.GetActorSnapshotRequest + (*GetActorSnapshotTagRequest)(nil), // 74: ateapi.GetActorSnapshotTagRequest + (*ListActorSnapshotsRequest)(nil), // 75: ateapi.ListActorSnapshotsRequest + (*ListActorSnapshotsResponse)(nil), // 76: ateapi.ListActorSnapshotsResponse + (*CreateActorSnapshotTagRequest)(nil), // 77: ateapi.CreateActorSnapshotTagRequest + (*UpdateActorSnapshotTagRequest)(nil), // 78: ateapi.UpdateActorSnapshotTagRequest + (*DeleteActorSnapshotTagRequest)(nil), // 79: ateapi.DeleteActorSnapshotTagRequest + (*DeleteOptions)(nil), // 80: ateapi.DeleteOptions + (*ListWorkersRequest)(nil), // 81: ateapi.ListWorkersRequest + (*ListWorkersResponse)(nil), // 82: ateapi.ListWorkersResponse + (*GetWorkerRequest)(nil), // 83: ateapi.GetWorkerRequest + (*CreateWorkerRequest)(nil), // 84: ateapi.CreateWorkerRequest + (*UpdateWorkerRequest)(nil), // 85: ateapi.UpdateWorkerRequest + (*DeleteWorkerRequest)(nil), // 86: ateapi.DeleteWorkerRequest + (*DrainWorkerRequest)(nil), // 87: ateapi.DrainWorkerRequest + (*ListActorsRequest)(nil), // 88: ateapi.ListActorsRequest + (*ListActorsResponse)(nil), // 89: ateapi.ListActorsResponse + (*Worker)(nil), // 90: ateapi.Worker + (*WorkerStatus)(nil), // 91: ateapi.WorkerStatus + (*WorkerCapacity)(nil), // 92: ateapi.WorkerCapacity + (*ActorAssignment)(nil), // 93: ateapi.ActorAssignment + (*KubeNamespacedObjectRef)(nil), // 94: ateapi.KubeNamespacedObjectRef + (*DebugClearRequest)(nil), // 95: ateapi.DebugClearRequest + (*DebugClearResponse)(nil), // 96: ateapi.DebugClearResponse + (*MintJWTRequest)(nil), // 97: ateapi.MintJWTRequest + (*MintJWTResponse)(nil), // 98: ateapi.MintJWTResponse + (*MintCertRequest)(nil), // 99: ateapi.MintCertRequest + (*MintCertResponse)(nil), // 100: ateapi.MintCertResponse + nil, // 101: ateapi.Selector.MatchLabelsEntry + nil, // 102: ateapi.ExternalVolume.VolumeContextEntry + nil, // 103: ateapi.SandboxAssets.AssetsEntry + nil, // 104: ateapi.ArchAssets.FilesEntry + nil, // 105: ateapi.Worker.LabelsEntry + (*timestamppb.Timestamp)(nil), // 106: google.protobuf.Timestamp + (*emptypb.Empty)(nil), // 107: google.protobuf.Empty } var file_ateapi_proto_depIdxs = []int32{ 0, // 0: ateapi.LocalSnapshotInfo.content_scope:type_name -> ateapi.SnapshotContentScope - 88, // 1: ateapi.Selector.match_labels:type_name -> ateapi.Selector.MatchLabelsEntry - 93, // 2: ateapi.ResourceMetadata.create_time:type_name -> google.protobuf.Timestamp - 93, // 3: ateapi.ResourceMetadata.update_time:type_name -> google.protobuf.Timestamp + 101, // 1: ateapi.Selector.match_labels:type_name -> ateapi.Selector.MatchLabelsEntry + 106, // 2: ateapi.ResourceMetadata.create_time:type_name -> google.protobuf.Timestamp + 106, // 3: ateapi.ResourceMetadata.update_time:type_name -> google.protobuf.Timestamp 8, // 4: ateapi.ExternalVolume.status:type_name -> ateapi.ExternalVolume.Status - 89, // 5: ateapi.ExternalVolume.volume_context:type_name -> ateapi.ExternalVolume.VolumeContextEntry + 102, // 5: ateapi.ExternalVolume.volume_context:type_name -> ateapi.ExternalVolume.VolumeContextEntry 11, // 6: ateapi.Actor.metadata:type_name -> ateapi.ResourceMetadata - 21, // 7: ateapi.Actor.actor_template:type_name -> ateapi.ObjectRef + 30, // 7: ateapi.Actor.actor_template:type_name -> ateapi.ObjectRef 10, // 8: ateapi.Actor.worker_selector:type_name -> ateapi.Selector - 21, // 9: ateapi.Actor.source_snapshot_tag:type_name -> ateapi.ObjectRef - 14, // 10: ateapi.Actor.status:type_name -> ateapi.ActorStatus - 2, // 11: ateapi.ActorStatus.state:type_name -> ateapi.ActorState - 16, // 12: ateapi.ActorStatus.worker_assignment:type_name -> ateapi.WorkerAssignment - 21, // 13: ateapi.ActorStatus.latest_snapshot:type_name -> ateapi.ObjectRef - 9, // 14: ateapi.ActorStatus.local_snapshot_info:type_name -> ateapi.LocalSnapshotInfo - 12, // 15: ateapi.ActorStatus.actor_volumes:type_name -> ateapi.ExternalVolume - 15, // 16: ateapi.ActorStatus.source_snapshot:type_name -> ateapi.ActorSourceSnapshotStatus - 21, // 17: ateapi.ActorSourceSnapshotStatus.snapshot:type_name -> ateapi.ObjectRef - 21, // 18: ateapi.WorkerAssignment.worker:type_name -> ateapi.ObjectRef - 11, // 19: ateapi.ActorSnapshot.metadata:type_name -> ateapi.ResourceMetadata - 18, // 20: ateapi.ActorSnapshot.status:type_name -> ateapi.ActorSnapshotStatus - 21, // 21: ateapi.ActorSnapshotStatus.source_actor:type_name -> ateapi.ObjectRef - 0, // 22: ateapi.ActorSnapshotStatus.content_scope:type_name -> ateapi.SnapshotContentScope - 21, // 23: ateapi.ActorSnapshotStatus.actor_template:type_name -> ateapi.ObjectRef - 11, // 24: ateapi.ActorSnapshotTag.metadata:type_name -> ateapi.ResourceMetadata - 21, // 25: ateapi.ActorSnapshotTag.snapshot:type_name -> ateapi.ObjectRef - 1, // 26: ateapi.ActorSnapshotTag.scope:type_name -> ateapi.ActorSnapshotTagScope - 11, // 27: ateapi.Atespace.metadata:type_name -> ateapi.ResourceMetadata - 11, // 28: ateapi.ActorTemplate.metadata:type_name -> ateapi.ResourceMetadata - 10, // 29: ateapi.ActorTemplate.worker_selector:type_name -> ateapi.Selector - 29, // 30: ateapi.ActorTemplate.containers:type_name -> ateapi.Container - 33, // 31: ateapi.ActorTemplate.volumes:type_name -> ateapi.Volume - 27, // 32: ateapi.ActorTemplate.snapshots_config:type_name -> ateapi.SnapshotsConfig - 26, // 33: ateapi.ActorTemplate.sandbox_config:type_name -> ateapi.SandboxConfig - 23, // 34: ateapi.ActorTemplate.resources:type_name -> ateapi.Resources - 25, // 35: ateapi.ActorTemplate.status:type_name -> ateapi.ActorTemplateStatus - 24, // 36: ateapi.Resources.limits:type_name -> ateapi.Limits - 4, // 37: ateapi.ActorTemplateStatus.phase:type_name -> ateapi.ActorTemplatePhase - 21, // 38: ateapi.ActorTemplateStatus.golden_snapshot:type_name -> ateapi.ObjectRef - 37, // 39: ateapi.ActorTemplateStatus.sandbox_assets:type_name -> ateapi.SandboxAssets - 3, // 40: ateapi.SandboxConfig.sandbox_class:type_name -> ateapi.SandboxClass - 0, // 41: ateapi.SnapshotsConfig.on_pause:type_name -> ateapi.SnapshotContentScope - 0, // 42: ateapi.SnapshotsConfig.on_commit:type_name -> ateapi.SnapshotContentScope - 28, // 43: ateapi.SnapshotsConfig.on_resume:type_name -> ateapi.OnResumeConfig - 5, // 44: ateapi.OnResumeConfig.from_data:type_name -> ateapi.ResumeSource - 30, // 45: ateapi.Container.env:type_name -> ateapi.EnvVar - 31, // 46: ateapi.Container.readyz:type_name -> ateapi.ContainerReadyz - 36, // 47: ateapi.Container.volume_mounts:type_name -> ateapi.VolumeMount - 32, // 48: ateapi.ContainerReadyz.http_get:type_name -> ateapi.HTTPGetAction - 34, // 49: ateapi.Volume.durable_dir:type_name -> ateapi.DurableDirVolumeSource - 35, // 50: ateapi.Volume.external_volume_template:type_name -> ateapi.ExternalVolumeTemplate - 3, // 51: ateapi.SandboxAssets.sandbox_class:type_name -> ateapi.SandboxClass - 90, // 52: ateapi.SandboxAssets.assets:type_name -> ateapi.SandboxAssets.AssetsEntry - 91, // 53: ateapi.ArchAssets.files:type_name -> ateapi.ArchAssets.FilesEntry - 20, // 54: ateapi.CreateAtespaceRequest.atespace:type_name -> ateapi.Atespace - 21, // 55: ateapi.GetAtespaceRequest.atespace:type_name -> ateapi.ObjectRef - 20, // 56: ateapi.ListAtespacesResponse.atespaces:type_name -> ateapi.Atespace - 21, // 57: ateapi.DeleteAtespaceRequest.atespace:type_name -> ateapi.ObjectRef - 22, // 58: ateapi.CreateActorTemplateRequest.actor_template:type_name -> ateapi.ActorTemplate - 21, // 59: ateapi.GetActorTemplateRequest.actor_template:type_name -> ateapi.ObjectRef - 22, // 60: ateapi.ListActorTemplatesResponse.actor_templates:type_name -> ateapi.ActorTemplate - 21, // 61: ateapi.DeleteActorTemplateRequest.actor_template:type_name -> ateapi.ObjectRef - 21, // 62: ateapi.GetActorRequest.actor:type_name -> ateapi.ObjectRef - 13, // 63: ateapi.CreateActorRequest.actor:type_name -> ateapi.Actor - 13, // 64: ateapi.UpdateActorRequest.actor:type_name -> ateapi.Actor - 21, // 65: ateapi.SuspendActorRequest.actor:type_name -> ateapi.ObjectRef - 13, // 66: ateapi.SuspendActorResponse.actor:type_name -> ateapi.Actor - 21, // 67: ateapi.PauseActorRequest.actor:type_name -> ateapi.ObjectRef - 13, // 68: ateapi.PauseActorResponse.actor:type_name -> ateapi.Actor - 21, // 69: ateapi.ResumeActorRequest.actor:type_name -> ateapi.ObjectRef - 13, // 70: ateapi.ResumeActorResponse.actor:type_name -> ateapi.Actor - 21, // 71: ateapi.DeleteActorRequest.actor:type_name -> ateapi.ObjectRef - 21, // 72: ateapi.GetActorSnapshotRequest.actor_snapshot:type_name -> ateapi.ObjectRef - 21, // 73: ateapi.GetActorSnapshotTagRequest.actor_snapshot_tag:type_name -> ateapi.ObjectRef - 17, // 74: ateapi.ListActorSnapshotsResponse.actor_snapshots:type_name -> ateapi.ActorSnapshot - 19, // 75: ateapi.CreateActorSnapshotTagRequest.actor_snapshot_tag:type_name -> ateapi.ActorSnapshotTag - 19, // 76: ateapi.UpdateActorSnapshotTagRequest.actor_snapshot_tag:type_name -> ateapi.ActorSnapshotTag - 21, // 77: ateapi.DeleteActorSnapshotTagRequest.actor_snapshot_tag:type_name -> ateapi.ObjectRef - 77, // 78: ateapi.ListWorkersResponse.workers:type_name -> ateapi.Worker - 21, // 79: ateapi.GetWorkerRequest.worker:type_name -> ateapi.ObjectRef - 77, // 80: ateapi.CreateWorkerRequest.worker:type_name -> ateapi.Worker - 77, // 81: ateapi.UpdateWorkerRequest.worker:type_name -> ateapi.Worker - 21, // 82: ateapi.DeleteWorkerRequest.worker:type_name -> ateapi.ObjectRef - 67, // 83: ateapi.DeleteWorkerRequest.options:type_name -> ateapi.DeleteOptions - 21, // 84: ateapi.DrainWorkerRequest.worker:type_name -> ateapi.ObjectRef - 13, // 85: ateapi.ListActorsResponse.actors:type_name -> ateapi.Actor - 11, // 86: ateapi.Worker.metadata:type_name -> ateapi.ResourceMetadata - 92, // 87: ateapi.Worker.labels:type_name -> ateapi.Worker.LabelsEntry - 79, // 88: ateapi.Worker.capacity:type_name -> ateapi.WorkerCapacity - 78, // 89: ateapi.Worker.status:type_name -> ateapi.WorkerStatus - 6, // 90: ateapi.WorkerStatus.state:type_name -> ateapi.WorkerState - 80, // 91: ateapi.WorkerStatus.assignment:type_name -> ateapi.ActorAssignment - 81, // 92: ateapi.ActorAssignment.actor_template:type_name -> ateapi.KubeNamespacedObjectRef - 21, // 93: ateapi.ActorAssignment.actor:type_name -> ateapi.ObjectRef - 21, // 94: ateapi.MintCertRequest.worker:type_name -> ateapi.ObjectRef - 7, // 95: ateapi.MintCertRequest.purpose:type_name -> ateapi.ActorCertificatePurpose - 38, // 96: ateapi.SandboxAssets.AssetsEntry.value:type_name -> ateapi.ArchAssets - 39, // 97: ateapi.ArchAssets.FilesEntry.value:type_name -> ateapi.AssetFile - 50, // 98: ateapi.Control.GetActor:input_type -> ateapi.GetActorRequest - 51, // 99: ateapi.Control.CreateActor:input_type -> ateapi.CreateActorRequest - 52, // 100: ateapi.Control.UpdateActor:input_type -> ateapi.UpdateActorRequest - 53, // 101: ateapi.Control.SuspendActor:input_type -> ateapi.SuspendActorRequest - 55, // 102: ateapi.Control.PauseActor:input_type -> ateapi.PauseActorRequest - 57, // 103: ateapi.Control.ResumeActor:input_type -> ateapi.ResumeActorRequest - 59, // 104: ateapi.Control.DeleteActor:input_type -> ateapi.DeleteActorRequest - 60, // 105: ateapi.Control.GetActorSnapshot:input_type -> ateapi.GetActorSnapshotRequest - 61, // 106: ateapi.Control.GetActorSnapshotTag:input_type -> ateapi.GetActorSnapshotTagRequest - 62, // 107: ateapi.Control.ListActorSnapshots:input_type -> ateapi.ListActorSnapshotsRequest - 64, // 108: ateapi.Control.CreateActorSnapshotTag:input_type -> ateapi.CreateActorSnapshotTagRequest - 65, // 109: ateapi.Control.UpdateActorSnapshotTag:input_type -> ateapi.UpdateActorSnapshotTagRequest - 66, // 110: ateapi.Control.DeleteActorSnapshotTag:input_type -> ateapi.DeleteActorSnapshotTagRequest - 68, // 111: ateapi.Control.ListWorkers:input_type -> ateapi.ListWorkersRequest - 70, // 112: ateapi.Control.GetWorker:input_type -> ateapi.GetWorkerRequest - 71, // 113: ateapi.Control.CreateWorker:input_type -> ateapi.CreateWorkerRequest - 72, // 114: ateapi.Control.UpdateWorker:input_type -> ateapi.UpdateWorkerRequest - 73, // 115: ateapi.Control.DeleteWorker:input_type -> ateapi.DeleteWorkerRequest - 74, // 116: ateapi.Control.DrainWorker:input_type -> ateapi.DrainWorkerRequest - 75, // 117: ateapi.Control.ListActors:input_type -> ateapi.ListActorsRequest - 40, // 118: ateapi.Control.CreateAtespace:input_type -> ateapi.CreateAtespaceRequest - 41, // 119: ateapi.Control.GetAtespace:input_type -> ateapi.GetAtespaceRequest - 42, // 120: ateapi.Control.ListAtespaces:input_type -> ateapi.ListAtespacesRequest - 44, // 121: ateapi.Control.DeleteAtespace:input_type -> ateapi.DeleteAtespaceRequest - 45, // 122: ateapi.Control.CreateActorTemplate:input_type -> ateapi.CreateActorTemplateRequest - 46, // 123: ateapi.Control.GetActorTemplate:input_type -> ateapi.GetActorTemplateRequest - 47, // 124: ateapi.Control.ListActorTemplates:input_type -> ateapi.ListActorTemplatesRequest - 49, // 125: ateapi.Control.DeleteActorTemplate:input_type -> ateapi.DeleteActorTemplateRequest - 82, // 126: ateapi.Debug.DebugClear:input_type -> ateapi.DebugClearRequest - 84, // 127: ateapi.ActorIdentity.MintJWT:input_type -> ateapi.MintJWTRequest - 86, // 128: ateapi.ActorIdentity.MintCert:input_type -> ateapi.MintCertRequest - 13, // 129: ateapi.Control.GetActor:output_type -> ateapi.Actor - 13, // 130: ateapi.Control.CreateActor:output_type -> ateapi.Actor - 13, // 131: ateapi.Control.UpdateActor:output_type -> ateapi.Actor - 54, // 132: ateapi.Control.SuspendActor:output_type -> ateapi.SuspendActorResponse - 56, // 133: ateapi.Control.PauseActor:output_type -> ateapi.PauseActorResponse - 58, // 134: ateapi.Control.ResumeActor:output_type -> ateapi.ResumeActorResponse - 13, // 135: ateapi.Control.DeleteActor:output_type -> ateapi.Actor - 17, // 136: ateapi.Control.GetActorSnapshot:output_type -> ateapi.ActorSnapshot - 19, // 137: ateapi.Control.GetActorSnapshotTag:output_type -> ateapi.ActorSnapshotTag - 63, // 138: ateapi.Control.ListActorSnapshots:output_type -> ateapi.ListActorSnapshotsResponse - 19, // 139: ateapi.Control.CreateActorSnapshotTag:output_type -> ateapi.ActorSnapshotTag - 19, // 140: ateapi.Control.UpdateActorSnapshotTag:output_type -> ateapi.ActorSnapshotTag - 19, // 141: ateapi.Control.DeleteActorSnapshotTag:output_type -> ateapi.ActorSnapshotTag - 69, // 142: ateapi.Control.ListWorkers:output_type -> ateapi.ListWorkersResponse - 77, // 143: ateapi.Control.GetWorker:output_type -> ateapi.Worker - 77, // 144: ateapi.Control.CreateWorker:output_type -> ateapi.Worker - 77, // 145: ateapi.Control.UpdateWorker:output_type -> ateapi.Worker - 77, // 146: ateapi.Control.DeleteWorker:output_type -> ateapi.Worker - 77, // 147: ateapi.Control.DrainWorker:output_type -> ateapi.Worker - 76, // 148: ateapi.Control.ListActors:output_type -> ateapi.ListActorsResponse - 20, // 149: ateapi.Control.CreateAtespace:output_type -> ateapi.Atespace - 20, // 150: ateapi.Control.GetAtespace:output_type -> ateapi.Atespace - 43, // 151: ateapi.Control.ListAtespaces:output_type -> ateapi.ListAtespacesResponse - 20, // 152: ateapi.Control.DeleteAtespace:output_type -> ateapi.Atespace - 22, // 153: ateapi.Control.CreateActorTemplate:output_type -> ateapi.ActorTemplate - 22, // 154: ateapi.Control.GetActorTemplate:output_type -> ateapi.ActorTemplate - 48, // 155: ateapi.Control.ListActorTemplates:output_type -> ateapi.ListActorTemplatesResponse - 22, // 156: ateapi.Control.DeleteActorTemplate:output_type -> ateapi.ActorTemplate - 83, // 157: ateapi.Debug.DebugClear:output_type -> ateapi.DebugClearResponse - 85, // 158: ateapi.ActorIdentity.MintJWT:output_type -> ateapi.MintJWTResponse - 87, // 159: ateapi.ActorIdentity.MintCert:output_type -> ateapi.MintCertResponse - 129, // [129:160] is the sub-list for method output_type - 98, // [98:129] is the sub-list for method input_type - 98, // [98:98] is the sub-list for extension type_name - 98, // [98:98] is the sub-list for extension extendee - 0, // [0:98] is the sub-list for field type_name + 30, // 9: ateapi.Actor.source_snapshot_tag:type_name -> ateapi.ObjectRef + 23, // 10: ateapi.Actor.status:type_name -> ateapi.ActorStatus + 11, // 11: ateapi.EgressPolicy.metadata:type_name -> ateapi.ResourceMetadata + 15, // 12: ateapi.EgressPolicy.rules:type_name -> ateapi.EgressRule + 16, // 13: ateapi.EgressRule.allow:type_name -> ateapi.EgressMatch + 19, // 14: ateapi.EgressRule.effects:type_name -> ateapi.EgressRuleEffects + 107, // 15: ateapi.EgressMatch.all:type_name -> google.protobuf.Empty + 17, // 16: ateapi.EgressMatch.hostname:type_name -> ateapi.HostnameMatch + 18, // 17: ateapi.EgressMatch.ip_block:type_name -> ateapi.IPBlockMatch + 20, // 18: ateapi.EgressRuleEffects.inject_static_header:type_name -> ateapi.StaticHeaderInjection + 21, // 19: ateapi.EgressRuleEffects.inject_actor_jwt:type_name -> ateapi.ActorTokenInjection + 22, // 20: ateapi.ActorTokenInjection.rfc_8693_exchange:type_name -> ateapi.RFC8693ExchangeParameters + 2, // 21: ateapi.ActorStatus.state:type_name -> ateapi.ActorState + 25, // 22: ateapi.ActorStatus.worker_assignment:type_name -> ateapi.WorkerAssignment + 30, // 23: ateapi.ActorStatus.latest_snapshot:type_name -> ateapi.ObjectRef + 9, // 24: ateapi.ActorStatus.local_snapshot_info:type_name -> ateapi.LocalSnapshotInfo + 12, // 25: ateapi.ActorStatus.actor_volumes:type_name -> ateapi.ExternalVolume + 24, // 26: ateapi.ActorStatus.source_snapshot:type_name -> ateapi.ActorSourceSnapshotStatus + 30, // 27: ateapi.ActorSourceSnapshotStatus.snapshot:type_name -> ateapi.ObjectRef + 30, // 28: ateapi.WorkerAssignment.worker:type_name -> ateapi.ObjectRef + 11, // 29: ateapi.ActorSnapshot.metadata:type_name -> ateapi.ResourceMetadata + 27, // 30: ateapi.ActorSnapshot.status:type_name -> ateapi.ActorSnapshotStatus + 30, // 31: ateapi.ActorSnapshotStatus.source_actor:type_name -> ateapi.ObjectRef + 0, // 32: ateapi.ActorSnapshotStatus.content_scope:type_name -> ateapi.SnapshotContentScope + 30, // 33: ateapi.ActorSnapshotStatus.actor_template:type_name -> ateapi.ObjectRef + 11, // 34: ateapi.ActorSnapshotTag.metadata:type_name -> ateapi.ResourceMetadata + 30, // 35: ateapi.ActorSnapshotTag.snapshot:type_name -> ateapi.ObjectRef + 1, // 36: ateapi.ActorSnapshotTag.scope:type_name -> ateapi.ActorSnapshotTagScope + 11, // 37: ateapi.Atespace.metadata:type_name -> ateapi.ResourceMetadata + 11, // 38: ateapi.ActorTemplate.metadata:type_name -> ateapi.ResourceMetadata + 10, // 39: ateapi.ActorTemplate.worker_selector:type_name -> ateapi.Selector + 38, // 40: ateapi.ActorTemplate.containers:type_name -> ateapi.Container + 42, // 41: ateapi.ActorTemplate.volumes:type_name -> ateapi.Volume + 36, // 42: ateapi.ActorTemplate.snapshots_config:type_name -> ateapi.SnapshotsConfig + 35, // 43: ateapi.ActorTemplate.sandbox_config:type_name -> ateapi.SandboxConfig + 32, // 44: ateapi.ActorTemplate.resources:type_name -> ateapi.Resources + 34, // 45: ateapi.ActorTemplate.status:type_name -> ateapi.ActorTemplateStatus + 33, // 46: ateapi.Resources.limits:type_name -> ateapi.Limits + 4, // 47: ateapi.ActorTemplateStatus.phase:type_name -> ateapi.ActorTemplatePhase + 30, // 48: ateapi.ActorTemplateStatus.golden_snapshot:type_name -> ateapi.ObjectRef + 46, // 49: ateapi.ActorTemplateStatus.sandbox_assets:type_name -> ateapi.SandboxAssets + 3, // 50: ateapi.SandboxConfig.sandbox_class:type_name -> ateapi.SandboxClass + 0, // 51: ateapi.SnapshotsConfig.on_pause:type_name -> ateapi.SnapshotContentScope + 0, // 52: ateapi.SnapshotsConfig.on_commit:type_name -> ateapi.SnapshotContentScope + 37, // 53: ateapi.SnapshotsConfig.on_resume:type_name -> ateapi.OnResumeConfig + 5, // 54: ateapi.OnResumeConfig.from_data:type_name -> ateapi.ResumeSource + 39, // 55: ateapi.Container.env:type_name -> ateapi.EnvVar + 40, // 56: ateapi.Container.readyz:type_name -> ateapi.ContainerReadyz + 45, // 57: ateapi.Container.volume_mounts:type_name -> ateapi.VolumeMount + 41, // 58: ateapi.ContainerReadyz.http_get:type_name -> ateapi.HTTPGetAction + 43, // 59: ateapi.Volume.durable_dir:type_name -> ateapi.DurableDirVolumeSource + 44, // 60: ateapi.Volume.external_volume_template:type_name -> ateapi.ExternalVolumeTemplate + 3, // 61: ateapi.SandboxAssets.sandbox_class:type_name -> ateapi.SandboxClass + 103, // 62: ateapi.SandboxAssets.assets:type_name -> ateapi.SandboxAssets.AssetsEntry + 104, // 63: ateapi.ArchAssets.files:type_name -> ateapi.ArchAssets.FilesEntry + 29, // 64: ateapi.CreateAtespaceRequest.atespace:type_name -> ateapi.Atespace + 30, // 65: ateapi.GetAtespaceRequest.atespace:type_name -> ateapi.ObjectRef + 29, // 66: ateapi.ListAtespacesResponse.atespaces:type_name -> ateapi.Atespace + 30, // 67: ateapi.DeleteAtespaceRequest.atespace:type_name -> ateapi.ObjectRef + 31, // 68: ateapi.CreateActorTemplateRequest.actor_template:type_name -> ateapi.ActorTemplate + 30, // 69: ateapi.GetActorTemplateRequest.actor_template:type_name -> ateapi.ObjectRef + 31, // 70: ateapi.ListActorTemplatesResponse.actor_templates:type_name -> ateapi.ActorTemplate + 30, // 71: ateapi.DeleteActorTemplateRequest.actor_template:type_name -> ateapi.ObjectRef + 30, // 72: ateapi.GetActorRequest.actor:type_name -> ateapi.ObjectRef + 13, // 73: ateapi.CreateActorRequest.actor:type_name -> ateapi.Actor + 13, // 74: ateapi.UpdateActorRequest.actor:type_name -> ateapi.Actor + 30, // 75: ateapi.SuspendActorRequest.actor:type_name -> ateapi.ObjectRef + 13, // 76: ateapi.SuspendActorResponse.actor:type_name -> ateapi.Actor + 30, // 77: ateapi.PauseActorRequest.actor:type_name -> ateapi.ObjectRef + 13, // 78: ateapi.PauseActorResponse.actor:type_name -> ateapi.Actor + 30, // 79: ateapi.ResumeActorRequest.actor:type_name -> ateapi.ObjectRef + 13, // 80: ateapi.ResumeActorResponse.actor:type_name -> ateapi.Actor + 30, // 81: ateapi.DeleteActorRequest.actor:type_name -> ateapi.ObjectRef + 30, // 82: ateapi.GetActorEgressPolicyRequest.actor:type_name -> ateapi.ObjectRef + 30, // 83: ateapi.CreateActorEgressPolicyRequest.actor:type_name -> ateapi.ObjectRef + 14, // 84: ateapi.CreateActorEgressPolicyRequest.egress_policy:type_name -> ateapi.EgressPolicy + 30, // 85: ateapi.UpdateActorEgressPolicyRequest.actor:type_name -> ateapi.ObjectRef + 14, // 86: ateapi.UpdateActorEgressPolicyRequest.egress_policy:type_name -> ateapi.EgressPolicy + 30, // 87: ateapi.DeleteActorEgressPolicyRequest.actor:type_name -> ateapi.ObjectRef + 30, // 88: ateapi.GetActorSnapshotRequest.actor_snapshot:type_name -> ateapi.ObjectRef + 30, // 89: ateapi.GetActorSnapshotTagRequest.actor_snapshot_tag:type_name -> ateapi.ObjectRef + 26, // 90: ateapi.ListActorSnapshotsResponse.actor_snapshots:type_name -> ateapi.ActorSnapshot + 28, // 91: ateapi.CreateActorSnapshotTagRequest.actor_snapshot_tag:type_name -> ateapi.ActorSnapshotTag + 28, // 92: ateapi.UpdateActorSnapshotTagRequest.actor_snapshot_tag:type_name -> ateapi.ActorSnapshotTag + 30, // 93: ateapi.DeleteActorSnapshotTagRequest.actor_snapshot_tag:type_name -> ateapi.ObjectRef + 90, // 94: ateapi.ListWorkersResponse.workers:type_name -> ateapi.Worker + 30, // 95: ateapi.GetWorkerRequest.worker:type_name -> ateapi.ObjectRef + 90, // 96: ateapi.CreateWorkerRequest.worker:type_name -> ateapi.Worker + 90, // 97: ateapi.UpdateWorkerRequest.worker:type_name -> ateapi.Worker + 30, // 98: ateapi.DeleteWorkerRequest.worker:type_name -> ateapi.ObjectRef + 80, // 99: ateapi.DeleteWorkerRequest.options:type_name -> ateapi.DeleteOptions + 30, // 100: ateapi.DrainWorkerRequest.worker:type_name -> ateapi.ObjectRef + 13, // 101: ateapi.ListActorsResponse.actors:type_name -> ateapi.Actor + 11, // 102: ateapi.Worker.metadata:type_name -> ateapi.ResourceMetadata + 105, // 103: ateapi.Worker.labels:type_name -> ateapi.Worker.LabelsEntry + 92, // 104: ateapi.Worker.capacity:type_name -> ateapi.WorkerCapacity + 91, // 105: ateapi.Worker.status:type_name -> ateapi.WorkerStatus + 6, // 106: ateapi.WorkerStatus.state:type_name -> ateapi.WorkerState + 93, // 107: ateapi.WorkerStatus.assignment:type_name -> ateapi.ActorAssignment + 94, // 108: ateapi.ActorAssignment.actor_template:type_name -> ateapi.KubeNamespacedObjectRef + 30, // 109: ateapi.ActorAssignment.actor:type_name -> ateapi.ObjectRef + 30, // 110: ateapi.MintCertRequest.worker:type_name -> ateapi.ObjectRef + 7, // 111: ateapi.MintCertRequest.purpose:type_name -> ateapi.ActorCertificatePurpose + 47, // 112: ateapi.SandboxAssets.AssetsEntry.value:type_name -> ateapi.ArchAssets + 48, // 113: ateapi.ArchAssets.FilesEntry.value:type_name -> ateapi.AssetFile + 59, // 114: ateapi.Control.GetActor:input_type -> ateapi.GetActorRequest + 60, // 115: ateapi.Control.CreateActor:input_type -> ateapi.CreateActorRequest + 61, // 116: ateapi.Control.UpdateActor:input_type -> ateapi.UpdateActorRequest + 62, // 117: ateapi.Control.SuspendActor:input_type -> ateapi.SuspendActorRequest + 64, // 118: ateapi.Control.PauseActor:input_type -> ateapi.PauseActorRequest + 66, // 119: ateapi.Control.ResumeActor:input_type -> ateapi.ResumeActorRequest + 68, // 120: ateapi.Control.DeleteActor:input_type -> ateapi.DeleteActorRequest + 69, // 121: ateapi.Control.GetActorEgressPolicy:input_type -> ateapi.GetActorEgressPolicyRequest + 70, // 122: ateapi.Control.CreateActorEgressPolicy:input_type -> ateapi.CreateActorEgressPolicyRequest + 71, // 123: ateapi.Control.UpdateActorEgressPolicy:input_type -> ateapi.UpdateActorEgressPolicyRequest + 72, // 124: ateapi.Control.DeleteActorEgressPolicy:input_type -> ateapi.DeleteActorEgressPolicyRequest + 73, // 125: ateapi.Control.GetActorSnapshot:input_type -> ateapi.GetActorSnapshotRequest + 74, // 126: ateapi.Control.GetActorSnapshotTag:input_type -> ateapi.GetActorSnapshotTagRequest + 75, // 127: ateapi.Control.ListActorSnapshots:input_type -> ateapi.ListActorSnapshotsRequest + 77, // 128: ateapi.Control.CreateActorSnapshotTag:input_type -> ateapi.CreateActorSnapshotTagRequest + 78, // 129: ateapi.Control.UpdateActorSnapshotTag:input_type -> ateapi.UpdateActorSnapshotTagRequest + 79, // 130: ateapi.Control.DeleteActorSnapshotTag:input_type -> ateapi.DeleteActorSnapshotTagRequest + 81, // 131: ateapi.Control.ListWorkers:input_type -> ateapi.ListWorkersRequest + 83, // 132: ateapi.Control.GetWorker:input_type -> ateapi.GetWorkerRequest + 84, // 133: ateapi.Control.CreateWorker:input_type -> ateapi.CreateWorkerRequest + 85, // 134: ateapi.Control.UpdateWorker:input_type -> ateapi.UpdateWorkerRequest + 86, // 135: ateapi.Control.DeleteWorker:input_type -> ateapi.DeleteWorkerRequest + 87, // 136: ateapi.Control.DrainWorker:input_type -> ateapi.DrainWorkerRequest + 88, // 137: ateapi.Control.ListActors:input_type -> ateapi.ListActorsRequest + 49, // 138: ateapi.Control.CreateAtespace:input_type -> ateapi.CreateAtespaceRequest + 50, // 139: ateapi.Control.GetAtespace:input_type -> ateapi.GetAtespaceRequest + 51, // 140: ateapi.Control.ListAtespaces:input_type -> ateapi.ListAtespacesRequest + 53, // 141: ateapi.Control.DeleteAtespace:input_type -> ateapi.DeleteAtespaceRequest + 54, // 142: ateapi.Control.CreateActorTemplate:input_type -> ateapi.CreateActorTemplateRequest + 55, // 143: ateapi.Control.GetActorTemplate:input_type -> ateapi.GetActorTemplateRequest + 56, // 144: ateapi.Control.ListActorTemplates:input_type -> ateapi.ListActorTemplatesRequest + 58, // 145: ateapi.Control.DeleteActorTemplate:input_type -> ateapi.DeleteActorTemplateRequest + 95, // 146: ateapi.Debug.DebugClear:input_type -> ateapi.DebugClearRequest + 97, // 147: ateapi.ActorIdentity.MintJWT:input_type -> ateapi.MintJWTRequest + 99, // 148: ateapi.ActorIdentity.MintCert:input_type -> ateapi.MintCertRequest + 13, // 149: ateapi.Control.GetActor:output_type -> ateapi.Actor + 13, // 150: ateapi.Control.CreateActor:output_type -> ateapi.Actor + 13, // 151: ateapi.Control.UpdateActor:output_type -> ateapi.Actor + 63, // 152: ateapi.Control.SuspendActor:output_type -> ateapi.SuspendActorResponse + 65, // 153: ateapi.Control.PauseActor:output_type -> ateapi.PauseActorResponse + 67, // 154: ateapi.Control.ResumeActor:output_type -> ateapi.ResumeActorResponse + 13, // 155: ateapi.Control.DeleteActor:output_type -> ateapi.Actor + 14, // 156: ateapi.Control.GetActorEgressPolicy:output_type -> ateapi.EgressPolicy + 14, // 157: ateapi.Control.CreateActorEgressPolicy:output_type -> ateapi.EgressPolicy + 14, // 158: ateapi.Control.UpdateActorEgressPolicy:output_type -> ateapi.EgressPolicy + 14, // 159: ateapi.Control.DeleteActorEgressPolicy:output_type -> ateapi.EgressPolicy + 26, // 160: ateapi.Control.GetActorSnapshot:output_type -> ateapi.ActorSnapshot + 28, // 161: ateapi.Control.GetActorSnapshotTag:output_type -> ateapi.ActorSnapshotTag + 76, // 162: ateapi.Control.ListActorSnapshots:output_type -> ateapi.ListActorSnapshotsResponse + 28, // 163: ateapi.Control.CreateActorSnapshotTag:output_type -> ateapi.ActorSnapshotTag + 28, // 164: ateapi.Control.UpdateActorSnapshotTag:output_type -> ateapi.ActorSnapshotTag + 28, // 165: ateapi.Control.DeleteActorSnapshotTag:output_type -> ateapi.ActorSnapshotTag + 82, // 166: ateapi.Control.ListWorkers:output_type -> ateapi.ListWorkersResponse + 90, // 167: ateapi.Control.GetWorker:output_type -> ateapi.Worker + 90, // 168: ateapi.Control.CreateWorker:output_type -> ateapi.Worker + 90, // 169: ateapi.Control.UpdateWorker:output_type -> ateapi.Worker + 90, // 170: ateapi.Control.DeleteWorker:output_type -> ateapi.Worker + 90, // 171: ateapi.Control.DrainWorker:output_type -> ateapi.Worker + 89, // 172: ateapi.Control.ListActors:output_type -> ateapi.ListActorsResponse + 29, // 173: ateapi.Control.CreateAtespace:output_type -> ateapi.Atespace + 29, // 174: ateapi.Control.GetAtespace:output_type -> ateapi.Atespace + 52, // 175: ateapi.Control.ListAtespaces:output_type -> ateapi.ListAtespacesResponse + 29, // 176: ateapi.Control.DeleteAtespace:output_type -> ateapi.Atespace + 31, // 177: ateapi.Control.CreateActorTemplate:output_type -> ateapi.ActorTemplate + 31, // 178: ateapi.Control.GetActorTemplate:output_type -> ateapi.ActorTemplate + 57, // 179: ateapi.Control.ListActorTemplates:output_type -> ateapi.ListActorTemplatesResponse + 31, // 180: ateapi.Control.DeleteActorTemplate:output_type -> ateapi.ActorTemplate + 96, // 181: ateapi.Debug.DebugClear:output_type -> ateapi.DebugClearResponse + 98, // 182: ateapi.ActorIdentity.MintJWT:output_type -> ateapi.MintJWTResponse + 100, // 183: ateapi.ActorIdentity.MintCert:output_type -> ateapi.MintCertResponse + 149, // [149:184] is the sub-list for method output_type + 114, // [114:149] is the sub-list for method input_type + 114, // [114:114] is the sub-list for extension type_name + 114, // [114:114] is the sub-list for extension extendee + 0, // [0:114] is the sub-list for field type_name } func init() { file_ateapi_proto_init() } @@ -6040,7 +6934,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: 84, + NumMessages: 97, NumExtensions: 0, NumServices: 3, }, diff --git a/pkg/proto/ateapipb/ateapi.proto b/pkg/proto/ateapipb/ateapi.proto index 5e7b9f679..721b30a1e 100644 --- a/pkg/proto/ateapipb/ateapi.proto +++ b/pkg/proto/ateapipb/ateapi.proto @@ -16,6 +16,7 @@ syntax = "proto3"; package ateapi; +import "google/protobuf/empty.proto"; import "google/protobuf/timestamp.proto"; option go_package = "github.com/agent-substrate/substrate/pkg/proto/ateapipb"; @@ -45,6 +46,18 @@ service Control { // Delete an actor. Only suspended actors can be deleted. rpc DeleteActor(DeleteActorRequest) returns (Actor) {} + // Get the egress policy resource nested under an Actor. + rpc GetActorEgressPolicy(GetActorEgressPolicyRequest) returns (EgressPolicy) {} + + // Create the egress policy resource nested under an Actor. + rpc CreateActorEgressPolicy(CreateActorEgressPolicyRequest) returns (EgressPolicy) {} + + // Replace the egress policy resource nested under an Actor. + rpc UpdateActorEgressPolicy(UpdateActorEgressPolicyRequest) returns (EgressPolicy) {} + + // Delete the egress policy resource nested under an Actor. + rpc DeleteActorEgressPolicy(DeleteActorEgressPolicyRequest) returns (EgressPolicy) {} + // Get an ActorSnapshot. rpc GetActorSnapshot(GetActorSnapshotRequest) returns (ActorSnapshot) {} @@ -290,6 +303,162 @@ message Actor { ActorStatus status = 7; } +// EgressPolicy is an egress policy resource nested under an Actor. An Actor has +// at most one egress policy resource, named "default". +// +// +k8s:customValidation +message EgressPolicy { + // Standard resource metadata. Atespace must match the parent Actor and name + // must be "default". Both are caller-specified on create and immutable. + // UID, version, create_time, and update_time are server-managed. + // + // +k8s:required + // +k8s:subfield(atespace)=+k8s:required + ResourceMetadata metadata = 1; + + // A request is authorized when at least one rule matches. Effects from all + // matching rules are then applied once per rule. Rule order has no meaning. + // An empty rule list denies all traffic. + // + // +k8s:optional + repeated EgressRule rules = 2; +} + +message EgressRule { + // Entries are ORed. The rule matches when any entry matches. + // + // +k8s:required + repeated EgressMatch allow = 1; + + // Effects do not authorize traffic. They are applied only after at least one + // rule authorizes the request. + // + // +k8s:optional + EgressRuleEffects effects = 2; +} + +message EgressMatch { + // Matches every destination. Exactly one predicate must be set. + // + // +k8s:optional + // +k8s:unionMember + // +k8s:opaqueType + google.protobuf.Empty all = 1; + + // Matches when the request hostname satisfies the configured pattern. + // + // +k8s:optional + // +k8s:unionMember + HostnameMatch hostname = 2; + + // Matches when the original destination IP belongs to the configured block. + // + // +k8s:optional + // +k8s:unionMember + IPBlockMatch ip_block = 3; +} + +// +k8s:customValidation +message HostnameMatch { + // An ASCII DNS name, or a wildcard in the complete leftmost label. + // + // The pattern and candidate hostname are normalized to lowercase. One + // trailing dot is permitted and removed. An optional port is removed from an + // HTTP authority before candidate normalization. All labels must be non-empty + // DNS labels of at most 63 characters, containing only ASCII letters, digits, + // and hyphens, and must start and end with a letter or digit. The normalized + // name must be at most 253 characters. + // + // A pattern without a wildcard matches only the complete normalized name. + // "*.example.com" matches exactly one non-empty label, such as + // "api.example.com". It does not match "example.com" or + // "nested.api.example.com". No other wildcard syntax is accepted. + // + // The pattern must not be a URL, IP literal, host:port authority, or Unicode + // U-label. An IP-literal candidate never matches. Internationalized names + // must use their ASCII IDNA A-label form; no Unicode conversion is done. + // Empty labels, malformed authorities, and more than one trailing dot are + // invalid and fail closed. + // + // +k8s:required + string pattern = 1; +} + +// +k8s:customValidation +message IPBlockMatch { + // A canonical IPv4 or IPv6 CIDR prefix. The predicate matches when the + // original destination IP belongs to the prefix. + // + // +k8s:required + string cidr = 1; +} + +// EgressRuleEffects contains non-mutually-exclusive effects. No two effects in +// a policy may target the same case-insensitive header. +message EgressRuleEffects { + // Injects values retrieved from credential providers into request headers. + // + // +k8s:optional + repeated StaticHeaderInjection inject_static_header = 1; + + // Injects an Actor JWT, or its exchanged token, into a request header. + // + // +k8s:optional + ActorTokenInjection inject_actor_jwt = 2; +} + +// +k8s:customValidation +message StaticHeaderInjection { + // The case-insensitive HTTP request header to inject. + // + // +k8s:required + string header = 1; + + // For example, "Bearer " for the Authorization header. + string prefix = 2; + + // Source-agnostic reference interpreted by a registered credential provider: + // substrate-secret://// + // + // +k8s:required + string credential_uri = 3; +} + +// +k8s:customValidation +message ActorTokenInjection { + // The case-insensitive HTTP request header to inject. + // + // +k8s:required + string header = 1; + + // Audiences included in the minted Actor JWT. + repeated string audiences = 2; + + // When present, exchanges the Actor JWT at an RFC 8693 endpoint and injects + // the result. A returned expires_in value controls caching of the token. + RFC8693ExchangeParameters rfc_8693_exchange = 3; +} + +message RFC8693ExchangeParameters { + // The HTTPS URL of the RFC 8693 token exchange endpoint. + string url = 1; + + // Resource indicators sent in the token exchange request. + repeated string resources = 2; + + // Audience values sent in the token exchange request. + repeated string audiences = 3; + + // The requested access scope sent in the token exchange request. + string scope = 4; + + // The requested token type sent in the token exchange request. + string requested_token_type = 5; + + // subject_token and subject_token_type are set automatically. actor_token + // and actor_token_type are not used for this flow. +} + enum ActorState { ACTOR_STATE_UNSPECIFIED = 0; ACTOR_STATE_RESUMING = 1; @@ -869,6 +1038,52 @@ message DeleteActorRequest { bool any_state = 2; } +message GetActorEgressPolicyRequest { + // The parent Actor of the egress policy resource to retrieve. + // + // +k8s:required + // +k8s:subfield(atespace)=+k8s:required + ObjectRef actor = 1; +} + +// +k8s:customValidation +message CreateActorEgressPolicyRequest { + // Parent Actor under which to create the policy resource. + // + // +k8s:required + // +k8s:subfield(atespace)=+k8s:required + ObjectRef actor = 1; + + // The policy to create. metadata.name must be "default" and + // metadata.atespace must match actor.atespace. + // + // +k8s:required + EgressPolicy egress_policy = 2; +} + +// +k8s:customValidation +message UpdateActorEgressPolicyRequest { + // Parent Actor under which to update the policy resource. + // + // +k8s:required + // +k8s:subfield(atespace)=+k8s:required + ObjectRef actor = 1; + + // Full replacement. Metadata UID and version are required preconditions; + // atespace and name are immutable and must match the existing policy. + // + // +k8s:required + EgressPolicy egress_policy = 2; +} + +message DeleteActorEgressPolicyRequest { + // The parent Actor of the egress policy resource to delete. + // + // +k8s:required + // +k8s:subfield(atespace)=+k8s:required + ObjectRef actor = 1; +} + message GetActorSnapshotRequest { // +k8s:opaqueType ObjectRef actor_snapshot = 1; diff --git a/pkg/proto/ateapipb/ateapi_grpc.pb.go b/pkg/proto/ateapipb/ateapi_grpc.pb.go index 5157d1930..0bb9f4b38 100644 --- a/pkg/proto/ateapipb/ateapi_grpc.pb.go +++ b/pkg/proto/ateapipb/ateapi_grpc.pb.go @@ -33,34 +33,38 @@ import ( const _ = grpc.SupportPackageIsVersion9 const ( - Control_GetActor_FullMethodName = "/ateapi.Control/GetActor" - Control_CreateActor_FullMethodName = "/ateapi.Control/CreateActor" - Control_UpdateActor_FullMethodName = "/ateapi.Control/UpdateActor" - Control_SuspendActor_FullMethodName = "/ateapi.Control/SuspendActor" - Control_PauseActor_FullMethodName = "/ateapi.Control/PauseActor" - Control_ResumeActor_FullMethodName = "/ateapi.Control/ResumeActor" - Control_DeleteActor_FullMethodName = "/ateapi.Control/DeleteActor" - Control_GetActorSnapshot_FullMethodName = "/ateapi.Control/GetActorSnapshot" - Control_GetActorSnapshotTag_FullMethodName = "/ateapi.Control/GetActorSnapshotTag" - Control_ListActorSnapshots_FullMethodName = "/ateapi.Control/ListActorSnapshots" - Control_CreateActorSnapshotTag_FullMethodName = "/ateapi.Control/CreateActorSnapshotTag" - Control_UpdateActorSnapshotTag_FullMethodName = "/ateapi.Control/UpdateActorSnapshotTag" - Control_DeleteActorSnapshotTag_FullMethodName = "/ateapi.Control/DeleteActorSnapshotTag" - Control_ListWorkers_FullMethodName = "/ateapi.Control/ListWorkers" - Control_GetWorker_FullMethodName = "/ateapi.Control/GetWorker" - Control_CreateWorker_FullMethodName = "/ateapi.Control/CreateWorker" - Control_UpdateWorker_FullMethodName = "/ateapi.Control/UpdateWorker" - Control_DeleteWorker_FullMethodName = "/ateapi.Control/DeleteWorker" - Control_DrainWorker_FullMethodName = "/ateapi.Control/DrainWorker" - Control_ListActors_FullMethodName = "/ateapi.Control/ListActors" - Control_CreateAtespace_FullMethodName = "/ateapi.Control/CreateAtespace" - Control_GetAtespace_FullMethodName = "/ateapi.Control/GetAtespace" - Control_ListAtespaces_FullMethodName = "/ateapi.Control/ListAtespaces" - Control_DeleteAtespace_FullMethodName = "/ateapi.Control/DeleteAtespace" - Control_CreateActorTemplate_FullMethodName = "/ateapi.Control/CreateActorTemplate" - Control_GetActorTemplate_FullMethodName = "/ateapi.Control/GetActorTemplate" - Control_ListActorTemplates_FullMethodName = "/ateapi.Control/ListActorTemplates" - Control_DeleteActorTemplate_FullMethodName = "/ateapi.Control/DeleteActorTemplate" + Control_GetActor_FullMethodName = "/ateapi.Control/GetActor" + Control_CreateActor_FullMethodName = "/ateapi.Control/CreateActor" + Control_UpdateActor_FullMethodName = "/ateapi.Control/UpdateActor" + Control_SuspendActor_FullMethodName = "/ateapi.Control/SuspendActor" + Control_PauseActor_FullMethodName = "/ateapi.Control/PauseActor" + Control_ResumeActor_FullMethodName = "/ateapi.Control/ResumeActor" + Control_DeleteActor_FullMethodName = "/ateapi.Control/DeleteActor" + Control_GetActorEgressPolicy_FullMethodName = "/ateapi.Control/GetActorEgressPolicy" + Control_CreateActorEgressPolicy_FullMethodName = "/ateapi.Control/CreateActorEgressPolicy" + Control_UpdateActorEgressPolicy_FullMethodName = "/ateapi.Control/UpdateActorEgressPolicy" + Control_DeleteActorEgressPolicy_FullMethodName = "/ateapi.Control/DeleteActorEgressPolicy" + Control_GetActorSnapshot_FullMethodName = "/ateapi.Control/GetActorSnapshot" + Control_GetActorSnapshotTag_FullMethodName = "/ateapi.Control/GetActorSnapshotTag" + Control_ListActorSnapshots_FullMethodName = "/ateapi.Control/ListActorSnapshots" + Control_CreateActorSnapshotTag_FullMethodName = "/ateapi.Control/CreateActorSnapshotTag" + Control_UpdateActorSnapshotTag_FullMethodName = "/ateapi.Control/UpdateActorSnapshotTag" + Control_DeleteActorSnapshotTag_FullMethodName = "/ateapi.Control/DeleteActorSnapshotTag" + Control_ListWorkers_FullMethodName = "/ateapi.Control/ListWorkers" + Control_GetWorker_FullMethodName = "/ateapi.Control/GetWorker" + Control_CreateWorker_FullMethodName = "/ateapi.Control/CreateWorker" + Control_UpdateWorker_FullMethodName = "/ateapi.Control/UpdateWorker" + Control_DeleteWorker_FullMethodName = "/ateapi.Control/DeleteWorker" + Control_DrainWorker_FullMethodName = "/ateapi.Control/DrainWorker" + Control_ListActors_FullMethodName = "/ateapi.Control/ListActors" + Control_CreateAtespace_FullMethodName = "/ateapi.Control/CreateAtespace" + Control_GetAtespace_FullMethodName = "/ateapi.Control/GetAtespace" + Control_ListAtespaces_FullMethodName = "/ateapi.Control/ListAtespaces" + Control_DeleteAtespace_FullMethodName = "/ateapi.Control/DeleteAtespace" + Control_CreateActorTemplate_FullMethodName = "/ateapi.Control/CreateActorTemplate" + Control_GetActorTemplate_FullMethodName = "/ateapi.Control/GetActorTemplate" + Control_ListActorTemplates_FullMethodName = "/ateapi.Control/ListActorTemplates" + Control_DeleteActorTemplate_FullMethodName = "/ateapi.Control/DeleteActorTemplate" ) // ControlClient is the client API for Control service. @@ -85,6 +89,14 @@ type ControlClient interface { ResumeActor(ctx context.Context, in *ResumeActorRequest, opts ...grpc.CallOption) (*ResumeActorResponse, error) // Delete an actor. Only suspended actors can be deleted. DeleteActor(ctx context.Context, in *DeleteActorRequest, opts ...grpc.CallOption) (*Actor, error) + // Get the egress policy resource nested under an Actor. + GetActorEgressPolicy(ctx context.Context, in *GetActorEgressPolicyRequest, opts ...grpc.CallOption) (*EgressPolicy, error) + // Create the egress policy resource nested under an Actor. + CreateActorEgressPolicy(ctx context.Context, in *CreateActorEgressPolicyRequest, opts ...grpc.CallOption) (*EgressPolicy, error) + // Replace the egress policy resource nested under an Actor. + UpdateActorEgressPolicy(ctx context.Context, in *UpdateActorEgressPolicyRequest, opts ...grpc.CallOption) (*EgressPolicy, error) + // Delete the egress policy resource nested under an Actor. + DeleteActorEgressPolicy(ctx context.Context, in *DeleteActorEgressPolicyRequest, opts ...grpc.CallOption) (*EgressPolicy, error) // Get an ActorSnapshot. GetActorSnapshot(ctx context.Context, in *GetActorSnapshotRequest, opts ...grpc.CallOption) (*ActorSnapshot, error) // Get an ActorSnapshot tag. @@ -210,6 +222,46 @@ func (c *controlClient) DeleteActor(ctx context.Context, in *DeleteActorRequest, return out, nil } +func (c *controlClient) GetActorEgressPolicy(ctx context.Context, in *GetActorEgressPolicyRequest, opts ...grpc.CallOption) (*EgressPolicy, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(EgressPolicy) + err := c.cc.Invoke(ctx, Control_GetActorEgressPolicy_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *controlClient) CreateActorEgressPolicy(ctx context.Context, in *CreateActorEgressPolicyRequest, opts ...grpc.CallOption) (*EgressPolicy, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(EgressPolicy) + err := c.cc.Invoke(ctx, Control_CreateActorEgressPolicy_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *controlClient) UpdateActorEgressPolicy(ctx context.Context, in *UpdateActorEgressPolicyRequest, opts ...grpc.CallOption) (*EgressPolicy, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(EgressPolicy) + err := c.cc.Invoke(ctx, Control_UpdateActorEgressPolicy_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + +func (c *controlClient) DeleteActorEgressPolicy(ctx context.Context, in *DeleteActorEgressPolicyRequest, opts ...grpc.CallOption) (*EgressPolicy, error) { + cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) + out := new(EgressPolicy) + err := c.cc.Invoke(ctx, Control_DeleteActorEgressPolicy_FullMethodName, in, out, cOpts...) + if err != nil { + return nil, err + } + return out, nil +} + func (c *controlClient) GetActorSnapshot(ctx context.Context, in *GetActorSnapshotRequest, opts ...grpc.CallOption) (*ActorSnapshot, error) { cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...) out := new(ActorSnapshot) @@ -442,6 +494,14 @@ type ControlServer interface { ResumeActor(context.Context, *ResumeActorRequest) (*ResumeActorResponse, error) // Delete an actor. Only suspended actors can be deleted. DeleteActor(context.Context, *DeleteActorRequest) (*Actor, error) + // Get the egress policy resource nested under an Actor. + GetActorEgressPolicy(context.Context, *GetActorEgressPolicyRequest) (*EgressPolicy, error) + // Create the egress policy resource nested under an Actor. + CreateActorEgressPolicy(context.Context, *CreateActorEgressPolicyRequest) (*EgressPolicy, error) + // Replace the egress policy resource nested under an Actor. + UpdateActorEgressPolicy(context.Context, *UpdateActorEgressPolicyRequest) (*EgressPolicy, error) + // Delete the egress policy resource nested under an Actor. + DeleteActorEgressPolicy(context.Context, *DeleteActorEgressPolicyRequest) (*EgressPolicy, error) // Get an ActorSnapshot. GetActorSnapshot(context.Context, *GetActorSnapshotRequest) (*ActorSnapshot, error) // Get an ActorSnapshot tag. @@ -518,6 +578,18 @@ func (UnimplementedControlServer) ResumeActor(context.Context, *ResumeActorReque func (UnimplementedControlServer) DeleteActor(context.Context, *DeleteActorRequest) (*Actor, error) { return nil, status.Error(codes.Unimplemented, "method DeleteActor not implemented") } +func (UnimplementedControlServer) GetActorEgressPolicy(context.Context, *GetActorEgressPolicyRequest) (*EgressPolicy, error) { + return nil, status.Error(codes.Unimplemented, "method GetActorEgressPolicy not implemented") +} +func (UnimplementedControlServer) CreateActorEgressPolicy(context.Context, *CreateActorEgressPolicyRequest) (*EgressPolicy, error) { + return nil, status.Error(codes.Unimplemented, "method CreateActorEgressPolicy not implemented") +} +func (UnimplementedControlServer) UpdateActorEgressPolicy(context.Context, *UpdateActorEgressPolicyRequest) (*EgressPolicy, error) { + return nil, status.Error(codes.Unimplemented, "method UpdateActorEgressPolicy not implemented") +} +func (UnimplementedControlServer) DeleteActorEgressPolicy(context.Context, *DeleteActorEgressPolicyRequest) (*EgressPolicy, error) { + return nil, status.Error(codes.Unimplemented, "method DeleteActorEgressPolicy not implemented") +} func (UnimplementedControlServer) GetActorSnapshot(context.Context, *GetActorSnapshotRequest) (*ActorSnapshot, error) { return nil, status.Error(codes.Unimplemented, "method GetActorSnapshot not implemented") } @@ -728,6 +800,78 @@ func _Control_DeleteActor_Handler(srv interface{}, ctx context.Context, dec func return interceptor(ctx, in, info, handler) } +func _Control_GetActorEgressPolicy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(GetActorEgressPolicyRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ControlServer).GetActorEgressPolicy(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Control_GetActorEgressPolicy_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ControlServer).GetActorEgressPolicy(ctx, req.(*GetActorEgressPolicyRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Control_CreateActorEgressPolicy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(CreateActorEgressPolicyRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ControlServer).CreateActorEgressPolicy(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Control_CreateActorEgressPolicy_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ControlServer).CreateActorEgressPolicy(ctx, req.(*CreateActorEgressPolicyRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Control_UpdateActorEgressPolicy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(UpdateActorEgressPolicyRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ControlServer).UpdateActorEgressPolicy(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Control_UpdateActorEgressPolicy_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ControlServer).UpdateActorEgressPolicy(ctx, req.(*UpdateActorEgressPolicyRequest)) + } + return interceptor(ctx, in, info, handler) +} + +func _Control_DeleteActorEgressPolicy_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(DeleteActorEgressPolicyRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(ControlServer).DeleteActorEgressPolicy(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: Control_DeleteActorEgressPolicy_FullMethodName, + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(ControlServer).DeleteActorEgressPolicy(ctx, req.(*DeleteActorEgressPolicyRequest)) + } + return interceptor(ctx, in, info, handler) +} + func _Control_GetActorSnapshot_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(GetActorSnapshotRequest) if err := dec(in); err != nil { @@ -1141,6 +1285,22 @@ var Control_ServiceDesc = grpc.ServiceDesc{ MethodName: "DeleteActor", Handler: _Control_DeleteActor_Handler, }, + { + MethodName: "GetActorEgressPolicy", + Handler: _Control_GetActorEgressPolicy_Handler, + }, + { + MethodName: "CreateActorEgressPolicy", + Handler: _Control_CreateActorEgressPolicy_Handler, + }, + { + MethodName: "UpdateActorEgressPolicy", + Handler: _Control_UpdateActorEgressPolicy_Handler, + }, + { + MethodName: "DeleteActorEgressPolicy", + Handler: _Control_DeleteActorEgressPolicy_Handler, + }, { MethodName: "GetActorSnapshot", Handler: _Control_GetActorSnapshot_Handler,