diff --git a/contrib/tetragon-rthooks/go.mod b/contrib/tetragon-rthooks/go.mod index b7cc42b64cc..c3605c59e5a 100644 --- a/contrib/tetragon-rthooks/go.mod +++ b/contrib/tetragon-rthooks/go.mod @@ -9,7 +9,7 @@ require ( github.com/alecthomas/kong v1.4.0 github.com/cilium/lumberjack/v2 v2.4.0 github.com/cilium/tetragon/api v0.0.0-00010101000000-000000000000 - github.com/containerd/containerd/v2 v2.0.0 + github.com/containerd/containerd v1.7.18 github.com/containerd/nri v0.8.0 github.com/containers/common v0.61.0 github.com/google/cel-go v0.22.0 @@ -24,10 +24,10 @@ require ( cel.dev/expr v0.18.0 // indirect dario.cat/mergo v1.0.1 // indirect github.com/antlr4-go/antlr/v4 v4.13.0 // indirect - github.com/containerd/errdefs v0.3.0 // indirect + github.com/containerd/errdefs v1.0.0 // indirect github.com/containerd/log v0.1.0 // indirect github.com/containerd/ttrpc v1.2.6-0.20240827082320-b5cd6e4b3287 // indirect - github.com/containerd/typeurl/v2 v2.2.0 // indirect + github.com/containerd/typeurl/v2 v2.2.2 // indirect github.com/containers/storage v1.56.0 // indirect github.com/coreos/go-systemd/v22 v22.5.0 // indirect github.com/cyphar/filepath-securejoin v0.3.4 // indirect @@ -35,24 +35,24 @@ require ( github.com/docker/go-events v0.0.0-20190806004212-e31b211e4f1c // indirect github.com/godbus/dbus/v5 v5.1.0 // indirect github.com/gogo/protobuf v1.3.2 // indirect - github.com/kr/pretty v0.3.1 // indirect + github.com/kr/text v0.2.0 // indirect github.com/moby/sys/mountinfo v0.7.2 // indirect github.com/moby/sys/userns v0.1.0 // indirect github.com/opencontainers/go-digest v1.0.0 // indirect github.com/opencontainers/image-spec v1.1.0 // indirect github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect - github.com/rogpeppe/go-internal v1.11.0 // indirect + github.com/prometheus/procfs v0.15.1 // indirect github.com/sirupsen/logrus v1.9.3 // indirect github.com/stoewer/go-strcase v1.2.0 // indirect golang.org/x/exp v0.0.0-20241009180824-f66d83c29e7c // indirect golang.org/x/net v0.30.0 // indirect golang.org/x/sys v0.27.0 // indirect golang.org/x/text v0.20.0 // indirect - google.golang.org/genproto/googleapis/api v0.0.0-20240903143218-8af14fe29dc1 // indirect + google.golang.org/genproto/googleapis/api v0.0.0-20241007155032-5fefd90f89a9 // indirect google.golang.org/genproto/googleapis/rpc v0.0.0-20241021214115-324edc3d5d38 // indirect google.golang.org/protobuf v1.35.1 // indirect gopkg.in/yaml.v3 v3.0.1 // indirect - k8s.io/cri-api v0.27.1 // indirect + k8s.io/cri-api v0.31.2 // indirect ) replace github.com/cilium/tetragon/api => ../../api diff --git a/contrib/tetragon-rthooks/go.sum b/contrib/tetragon-rthooks/go.sum index 899c10f91ec..a29bfe3c481 100644 --- a/contrib/tetragon-rthooks/go.sum +++ b/contrib/tetragon-rthooks/go.sum @@ -15,20 +15,18 @@ github.com/antlr4-go/antlr/v4 v4.13.0 h1:lxCg3LAv+EUK6t1i0y1V6/SLeUi0eKEKdhQAlS8 github.com/antlr4-go/antlr/v4 v4.13.0/go.mod h1:pfChB/xh/Unjila75QW7+VU4TSnWnnk9UTnmpPaOR2g= github.com/cilium/lumberjack/v2 v2.4.0 h1:toQDgWpB9n2vBod79a5I7ZD/jTAVTrd+IW5ySdYQMmU= github.com/cilium/lumberjack/v2 v2.4.0/go.mod h1:yfbtPGmg4i//5oEqzaMxDqSWqgfZFmMoV70Mc2k6v0A= -github.com/containerd/containerd v1.7.23 h1:H2CClyUkmpKAGlhQp95g2WXHfLYc7whAuvZGBNYOOwQ= -github.com/containerd/containerd v1.7.23/go.mod h1:7QUzfURqZWCZV7RLNEn1XjUCQLEf0bkaK4GjUaZehxw= -github.com/containerd/containerd/api v1.7.19 h1:VWbJL+8Ap4Ju2mx9c9qS1uFSB1OVYr5JJrW2yT5vFoA= -github.com/containerd/containerd/api v1.7.19/go.mod h1:fwGavl3LNwAV5ilJ0sbrABL44AQxmNjDRcwheXDb6Ig= -github.com/containerd/errdefs v0.3.0 h1:FSZgGOeK4yuT/+DnF07/Olde/q4KBoMsaamhXxIMDp4= -github.com/containerd/errdefs v0.3.0/go.mod h1:+YBYIdtsnF4Iw6nWZhJcqGSg/dwvV7tyJ/kCkyJ2k+M= +github.com/containerd/containerd v1.7.18 h1:jqjZTQNfXGoEaZdW1WwPU0RqSn1Bm2Ay/KJPUuO8nao= +github.com/containerd/containerd v1.7.18/go.mod h1:IYEk9/IO6wAPUz2bCMVUbsfXjzw5UNP5fLz4PsUygQ4= +github.com/containerd/errdefs v1.0.0 h1:tg5yIfIlQIrxYtu9ajqY42W3lpS19XqdxRQeEwYG8PI= +github.com/containerd/errdefs v1.0.0/go.mod h1:+YBYIdtsnF4Iw6nWZhJcqGSg/dwvV7tyJ/kCkyJ2k+M= github.com/containerd/log v0.1.0 h1:TCJt7ioM2cr/tfR8GPbGf9/VRAX8D2B4PjzCpfX540I= github.com/containerd/log v0.1.0/go.mod h1:VRRf09a7mHDIRezVKTRCrOq78v577GXq3bSa3EhrzVo= github.com/containerd/nri v0.8.0 h1:n1S753B9lX8RFrHYeSgwVvS1yaUcHjxbB+f+xzEncRI= github.com/containerd/nri v0.8.0/go.mod h1:uSkgBrCdEtAiEz4vnrq8gmAC4EnVAM5Klt0OuK5rZYQ= github.com/containerd/ttrpc v1.2.6-0.20240827082320-b5cd6e4b3287 h1:zwv64tCdT888KxuXQuv5i36cEdljoXq3sVqLmOEbCQI= github.com/containerd/ttrpc v1.2.6-0.20240827082320-b5cd6e4b3287/go.mod h1:YCXHsb32f+Sq5/72xHubdiJRQY9inL4a4ZQrAbN1q9o= -github.com/containerd/typeurl/v2 v2.2.0 h1:6NBDbQzr7I5LHgp34xAXYF5DOTQDn05X58lsPEmzLso= -github.com/containerd/typeurl/v2 v2.2.0/go.mod h1:8XOOxnyatxSWuG8OfsZXVnAF4iZfedjS/8UHSPJnX4g= +github.com/containerd/typeurl/v2 v2.2.2 h1:3jN/k2ysKuPCsln5Qv8bzR9cxal8XjkxPogJfSNO31k= +github.com/containerd/typeurl/v2 v2.2.2/go.mod h1:95ljDnPfD3bAbDJRugOiShd/DlAAsxGtUBhJxIn7SCk= github.com/containers/common v0.61.0 h1:j/84PTqZIKKYy42OEJsZmjZ4g4Kq2ERuC3tqp2yWdh4= github.com/containers/common v0.61.0/go.mod h1:NGRISq2vTFPSbhNqj6MLwyes4tWSlCnqbJg7R77B8xc= github.com/containers/storage v1.56.0 h1:DZ9KSkj6M2tvj/4bBoaJu3QDHRl35BwsZ4kmLJS97ZI= @@ -87,15 +85,13 @@ github.com/opencontainers/runtime-spec v1.2.0 h1:z97+pHb3uELt/yiAWD691HNHQIF07bE github.com/opencontainers/runtime-spec v1.2.0/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0= github.com/pelletier/go-toml v1.9.5 h1:4yBQzkHv+7BHq2PQUZF3Mx0IYxG7LsP222s7Agd3ve8= github.com/pelletier/go-toml v1.9.5/go.mod h1:u1nR/EPcESfeI/szUZKdtJ0xRNbUoANCkoOuaOx1Y+c= -github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/prometheus/procfs v0.8.0 h1:ODq8ZFEaYeCaZOJlZZdJA2AbQR98dSHSM1KW/You5mo= -github.com/prometheus/procfs v0.8.0/go.mod h1:z7EfXMXOkbkqb9IINtpCn86r/to3BnA0uaxHdg830/4= -github.com/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= -github.com/rogpeppe/go-internal v1.11.0 h1:cWPaGQEPrBb5/AsnsZesgZZ9yb1OQ+GOISoDNXVBh4M= -github.com/rogpeppe/go-internal v1.11.0/go.mod h1:ddIwULY96R17DhadqLgMfk9H9tvdUzkipdSkR5nkCZA= +github.com/prometheus/procfs v0.15.1 h1:YagwOFzUgYfKKHX6Dr+sHT7km/hxC76UB0learggepc= +github.com/prometheus/procfs v0.15.1/go.mod h1:fB45yRUv8NstnjriLhBQLuOUt+WW4BsoGhij/e3PBqk= +github.com/rogpeppe/go-internal v1.12.0 h1:exVL4IDcn6na9z1rAb56Vxr+CgyK3nn3O+epU5NdKM8= +github.com/rogpeppe/go-internal v1.12.0/go.mod h1:E+RYuTGaKKdloAfM02xzb0FW3Paa99yedzYV+kq4uf4= github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ= github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ= github.com/stoewer/go-strcase v1.2.0 h1:Z2iHWqGXH00XYgqDmNgQbIBxf3wrNq0F3feEy0ainaU= @@ -143,8 +139,8 @@ golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8T golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= -google.golang.org/genproto/googleapis/api v0.0.0-20240903143218-8af14fe29dc1 h1:hjSy6tcFQZ171igDaN5QHOw2n6vx40juYbC/x67CEhc= -google.golang.org/genproto/googleapis/api v0.0.0-20240903143218-8af14fe29dc1/go.mod h1:qpvKtACPCQhAdu3PyQgV4l3LMXZEtft7y8QcarRsp9I= +google.golang.org/genproto/googleapis/api v0.0.0-20241007155032-5fefd90f89a9 h1:T6rh4haD3GVYsgEfWExoCZA2o2FmbNyKpTuAxbEFPTg= +google.golang.org/genproto/googleapis/api v0.0.0-20241007155032-5fefd90f89a9/go.mod h1:wp2WsuBYj6j8wUdo3ToZsdxxixbvQNAHqVJrTgi5E5M= google.golang.org/genproto/googleapis/rpc v0.0.0-20241021214115-324edc3d5d38 h1:zciRKQ4kBpFgpfC5QQCVtnnNAcLIqweL7plyZRQHVpI= google.golang.org/genproto/googleapis/rpc v0.0.0-20241021214115-324edc3d5d38/go.mod h1:GX3210XPVPUjJbTUbvwI8f2IpZDMZuPJWDzDuebbviI= google.golang.org/grpc v1.68.0 h1:aHQeeJbo8zAkAa3pRzrVjZlbz6uSfeOXlJNQM0RAbz0= @@ -160,5 +156,5 @@ gopkg.in/yaml.v2 v2.4.0/go.mod h1:RDklbk79AGWmwhnvt/jBztapEOGDOx6ZbXqjP6csGnQ= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -k8s.io/cri-api v0.27.1 h1:KWO+U8MfI9drXB/P4oU9VchaWYOlwDglJZVHWMpTT3Q= -k8s.io/cri-api v0.27.1/go.mod h1:+Ts/AVYbIo04S86XbTD73UPp/DkTiYxtsFeOFEu32L0= +k8s.io/cri-api v0.31.2 h1:O/weUnSHvM59nTio0unxIUFyRHMRKkYn96YDILSQKmo= +k8s.io/cri-api v0.31.2/go.mod h1:Po3TMAYH/+KrZabi7QiwQI4a692oZcUOUThd/rqwxrI= diff --git a/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/errdefs/errors.go b/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/errdefs/errors.go deleted file mode 100644 index de22cadd419..00000000000 --- a/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/errdefs/errors.go +++ /dev/null @@ -1,72 +0,0 @@ -/* - Copyright The containerd Authors. - - 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 errdefs defines the common errors used throughout containerd -// packages. -// -// Use with fmt.Errorf to add context to an error. -// -// To detect an error class, use the IsXXX functions to tell whether an error -// is of a certain type. -package errdefs - -import ( - "github.com/containerd/errdefs" -) - -// Definitions of common error types used throughout containerd. All containerd -// errors returned by most packages will map into one of these errors classes. -// Packages should return errors of these types when they want to instruct a -// client to take a particular action. -// -// These errors map closely to grpc errors. -var ( - ErrUnknown = errdefs.ErrUnknown - ErrInvalidArgument = errdefs.ErrInvalidArgument - ErrNotFound = errdefs.ErrNotFound - ErrAlreadyExists = errdefs.ErrAlreadyExists - ErrPermissionDenied = errdefs.ErrPermissionDenied - ErrResourceExhausted = errdefs.ErrResourceExhausted - ErrFailedPrecondition = errdefs.ErrFailedPrecondition - ErrConflict = errdefs.ErrConflict - ErrNotModified = errdefs.ErrNotModified - ErrAborted = errdefs.ErrAborted - ErrOutOfRange = errdefs.ErrOutOfRange - ErrNotImplemented = errdefs.ErrNotImplemented - ErrInternal = errdefs.ErrInternal - ErrUnavailable = errdefs.ErrUnavailable - ErrDataLoss = errdefs.ErrDataLoss - ErrUnauthenticated = errdefs.ErrUnauthenticated - - IsCanceled = errdefs.IsCanceled - IsUnknown = errdefs.IsUnknown - IsInvalidArgument = errdefs.IsInvalidArgument - IsDeadlineExceeded = errdefs.IsDeadlineExceeded - IsNotFound = errdefs.IsNotFound - IsAlreadyExists = errdefs.IsAlreadyExists - IsPermissionDenied = errdefs.IsPermissionDenied - IsResourceExhausted = errdefs.IsResourceExhausted - IsFailedPrecondition = errdefs.IsFailedPrecondition - IsConflict = errdefs.IsConflict - IsNotModified = errdefs.IsNotModified - IsAborted = errdefs.IsAborted - IsOutOfRange = errdefs.IsOutOfRange - IsNotImplemented = errdefs.IsNotImplemented - IsInternal = errdefs.IsInternal - IsUnavailable = errdefs.IsUnavailable - IsDataLoss = errdefs.IsDataLoss - IsUnauthorized = errdefs.IsUnauthorized -) diff --git a/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/errdefs/grpc.go b/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/errdefs/grpc.go deleted file mode 100644 index 7a9b33e05af..00000000000 --- a/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/errdefs/grpc.go +++ /dev/null @@ -1,147 +0,0 @@ -/* - Copyright The containerd Authors. - - 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 errdefs - -import ( - "context" - "fmt" - "strings" - - "google.golang.org/grpc/codes" - "google.golang.org/grpc/status" -) - -// ToGRPC will attempt to map the backend containerd error into a grpc error, -// using the original error message as a description. -// -// Further information may be extracted from certain errors depending on their -// type. -// -// If the error is unmapped, the original error will be returned to be handled -// by the regular grpc error handling stack. -func ToGRPC(err error) error { - if err == nil { - return nil - } - - if isGRPCError(err) { - // error has already been mapped to grpc - return err - } - - switch { - case IsInvalidArgument(err): - return status.Errorf(codes.InvalidArgument, err.Error()) - case IsNotFound(err): - return status.Errorf(codes.NotFound, err.Error()) - case IsAlreadyExists(err): - return status.Errorf(codes.AlreadyExists, err.Error()) - case IsFailedPrecondition(err): - return status.Errorf(codes.FailedPrecondition, err.Error()) - case IsUnavailable(err): - return status.Errorf(codes.Unavailable, err.Error()) - case IsNotImplemented(err): - return status.Errorf(codes.Unimplemented, err.Error()) - case IsCanceled(err): - return status.Errorf(codes.Canceled, err.Error()) - case IsDeadlineExceeded(err): - return status.Errorf(codes.DeadlineExceeded, err.Error()) - } - - return err -} - -// ToGRPCf maps the error to grpc error codes, assembling the formatting string -// and combining it with the target error string. -// -// This is equivalent to errdefs.ToGRPC(fmt.Errorf("%s: %w", fmt.Sprintf(format, args...), err)) -func ToGRPCf(err error, format string, args ...interface{}) error { - return ToGRPC(fmt.Errorf("%s: %w", fmt.Sprintf(format, args...), err)) -} - -// FromGRPC returns the underlying error from a grpc service based on the grpc error code -func FromGRPC(err error) error { - if err == nil { - return nil - } - - var cls error // divide these into error classes, becomes the cause - - switch code(err) { - case codes.InvalidArgument: - cls = ErrInvalidArgument - case codes.AlreadyExists: - cls = ErrAlreadyExists - case codes.NotFound: - cls = ErrNotFound - case codes.Unavailable: - cls = ErrUnavailable - case codes.FailedPrecondition: - cls = ErrFailedPrecondition - case codes.Unimplemented: - cls = ErrNotImplemented - case codes.Canceled: - cls = context.Canceled - case codes.DeadlineExceeded: - cls = context.DeadlineExceeded - default: - cls = ErrUnknown - } - - msg := rebaseMessage(cls, err) - if msg != "" { - err = fmt.Errorf("%s: %w", msg, cls) - } else { - err = cls - } - - return err -} - -// rebaseMessage removes the repeats for an error at the end of an error -// string. This will happen when taking an error over grpc then remapping it. -// -// Effectively, we just remove the string of cls from the end of err if it -// appears there. -func rebaseMessage(cls error, err error) string { - desc := errDesc(err) - clss := cls.Error() - if desc == clss { - return "" - } - - return strings.TrimSuffix(desc, ": "+clss) -} - -func isGRPCError(err error) bool { - _, ok := status.FromError(err) - return ok -} - -func code(err error) codes.Code { - if s, ok := status.FromError(err); ok { - return s.Code() - } - return codes.Unknown -} - -func errDesc(err error) string { - if s, ok := status.FromError(err); ok { - return s.Message() - } - return err.Error() -} diff --git a/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/events/exchange/exchange.go b/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/events/exchange/exchange.go index b3904490952..38c41f39571 100644 --- a/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/events/exchange/exchange.go +++ b/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/events/exchange/exchange.go @@ -22,15 +22,14 @@ import ( "strings" "time" - "github.com/containerd/log" - "github.com/containerd/typeurl/v2" - goevents "github.com/docker/go-events" - - "github.com/containerd/containerd/errdefs" "github.com/containerd/containerd/events" "github.com/containerd/containerd/filters" "github.com/containerd/containerd/identifiers" "github.com/containerd/containerd/namespaces" + "github.com/containerd/errdefs" + "github.com/containerd/log" + "github.com/containerd/typeurl/v2" + goevents "github.com/docker/go-events" ) // Exchange broadcasts events diff --git a/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/filters/parser.go b/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/filters/parser.go index 32767909b1c..f07fd33bd2d 100644 --- a/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/filters/parser.go +++ b/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/filters/parser.go @@ -20,7 +20,7 @@ import ( "fmt" "io" - "github.com/containerd/containerd/errdefs" + "github.com/containerd/errdefs" ) /* diff --git a/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/identifiers/validate.go b/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/identifiers/validate.go index cbd3a52ba9e..0acbf3fc4bb 100644 --- a/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/identifiers/validate.go +++ b/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/identifiers/validate.go @@ -28,7 +28,7 @@ import ( "fmt" "regexp" - "github.com/containerd/containerd/errdefs" + "github.com/containerd/errdefs" ) const ( diff --git a/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/namespaces/context.go b/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/namespaces/context.go index e5e23fe4301..94ef9408d1d 100644 --- a/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/namespaces/context.go +++ b/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/namespaces/context.go @@ -21,8 +21,8 @@ import ( "fmt" "os" - "github.com/containerd/containerd/errdefs" "github.com/containerd/containerd/identifiers" + "github.com/containerd/errdefs" ) const ( diff --git a/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/plugin/context.go b/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/plugin/context.go index 370508d28d1..d084564ea28 100644 --- a/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/plugin/context.go +++ b/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/plugin/context.go @@ -23,8 +23,8 @@ import ( ocispec "github.com/opencontainers/image-spec/specs-go/v1" - "github.com/containerd/containerd/errdefs" "github.com/containerd/containerd/events/exchange" + "github.com/containerd/errdefs" ) // InitContext is used for plugin initialization diff --git a/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/services/server/config/config.go b/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/services/server/config/config.go index e3fac1d8215..063e71c3d54 100644 --- a/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/services/server/config/config.go +++ b/contrib/tetragon-rthooks/vendor/github.com/containerd/containerd/services/server/config/config.go @@ -25,8 +25,8 @@ import ( "github.com/pelletier/go-toml" "github.com/sirupsen/logrus" - "github.com/containerd/containerd/errdefs" "github.com/containerd/containerd/plugin" + "github.com/containerd/errdefs" ) // NOTE: Any new map fields added also need to be handled in mergeConfig. @@ -170,11 +170,10 @@ type CgroupConfig struct { // ProxyPlugin provides a proxy plugin configuration type ProxyPlugin struct { - Type string `toml:"type"` - Address string `toml:"address"` - Platform string `toml:"platform"` - Exports map[string]string `toml:"exports"` - Capabilities []string `toml:"capabilities"` + Type string `toml:"type"` + Address string `toml:"address"` + Platform string `toml:"platform"` + Exports map[string]string `toml:"exports"` } // Decode unmarshals a plugin specific configuration by plugin id diff --git a/contrib/tetragon-rthooks/vendor/github.com/containerd/typeurl/v2/README.md b/contrib/tetragon-rthooks/vendor/github.com/containerd/typeurl/v2/README.md index 8d86600a40b..3098526ab1f 100644 --- a/contrib/tetragon-rthooks/vendor/github.com/containerd/typeurl/v2/README.md +++ b/contrib/tetragon-rthooks/vendor/github.com/containerd/typeurl/v2/README.md @@ -18,3 +18,9 @@ As a containerd sub-project, you will find the: * and [Contributing guidelines](https://github.com/containerd/project/blob/main/CONTRIBUTING.md) information in our [`containerd/project`](https://github.com/containerd/project) repository. + +## Optional + +By default, support for gogoproto is available along side the standard Google +protobuf types. +You can choose to leave gogo support out by using the `!no_gogo` build tag. diff --git a/contrib/tetragon-rthooks/vendor/github.com/containerd/typeurl/v2/types.go b/contrib/tetragon-rthooks/vendor/github.com/containerd/typeurl/v2/types.go index 78817b701e3..efc405ddd48 100644 --- a/contrib/tetragon-rthooks/vendor/github.com/containerd/typeurl/v2/types.go +++ b/contrib/tetragon-rthooks/vendor/github.com/containerd/typeurl/v2/types.go @@ -24,7 +24,6 @@ import ( "reflect" "sync" - gogoproto "github.com/gogo/protobuf/proto" "google.golang.org/protobuf/proto" "google.golang.org/protobuf/reflect/protoregistry" "google.golang.org/protobuf/types/known/anypb" @@ -33,8 +32,16 @@ import ( var ( mu sync.RWMutex registry = make(map[reflect.Type]string) + handlers []handler ) +type handler interface { + Marshaller(interface{}) func() ([]byte, error) + Unmarshaller(interface{}) func([]byte) error + TypeURL(interface{}) string + GetType(url string) reflect.Type +} + // Definitions of common error types used throughout typeurl. // // These error types are used with errors.Wrap and errors.Wrapf to add context @@ -112,9 +119,12 @@ func TypeURL(v interface{}) (string, error) { switch t := v.(type) { case proto.Message: return string(t.ProtoReflect().Descriptor().FullName()), nil - case gogoproto.Message: - return gogoproto.MessageName(t), nil default: + for _, h := range handlers { + if u := h.TypeURL(v); u != "" { + return u, nil + } + } return "", fmt.Errorf("type %s: %w", reflect.TypeOf(v), ErrNotFound) } } @@ -149,12 +159,19 @@ func MarshalAny(v interface{}) (Any, error) { marshal = func(v interface{}) ([]byte, error) { return proto.Marshal(t) } - case gogoproto.Message: - marshal = func(v interface{}) ([]byte, error) { - return gogoproto.Marshal(t) - } default: - marshal = json.Marshal + for _, h := range handlers { + if m := h.Marshaller(v); m != nil { + marshal = func(v interface{}) ([]byte, error) { + return m() + } + break + } + } + + if marshal == nil { + marshal = json.Marshal + } } url, err := TypeURL(v) @@ -229,7 +246,7 @@ func unmarshal(typeURL string, value []byte, v interface{}) (interface{}, error) } if v == nil { - v = reflect.New(t.t).Interface() + v = reflect.New(t).Interface() } else { // Validate interface type provided by client vURL, err := TypeURL(v) @@ -241,51 +258,43 @@ func unmarshal(typeURL string, value []byte, v interface{}) (interface{}, error) } } - if t.isProto { - switch t := v.(type) { - case proto.Message: - err = proto.Unmarshal(value, t) - case gogoproto.Message: - err = gogoproto.Unmarshal(value, t) - } - } else { - err = json.Unmarshal(value, v) + pm, ok := v.(proto.Message) + if ok { + return v, proto.Unmarshal(value, pm) } - return v, err -} + for _, h := range handlers { + if unmarshal := h.Unmarshaller(v); unmarshal != nil { + return v, unmarshal(value) + } + } -type urlType struct { - t reflect.Type - isProto bool + // fallback to json unmarshaller + return v, json.Unmarshal(value, v) } -func getTypeByUrl(url string) (urlType, error) { +func getTypeByUrl(url string) (reflect.Type, error) { mu.RLock() for t, u := range registry { if u == url { mu.RUnlock() - return urlType{ - t: t, - }, nil + return t, nil } } mu.RUnlock() - // fallback to proto registry - t := gogoproto.MessageType(url) - if t != nil { - return urlType{ - // get the underlying Elem because proto returns a pointer to the type - t: t.Elem(), - isProto: true, - }, nil - } mt, err := protoregistry.GlobalTypes.FindMessageByURL(url) if err != nil { - return urlType{}, fmt.Errorf("type with url %s: %w", url, ErrNotFound) + if errors.Is(err, protoregistry.NotFound) { + for _, h := range handlers { + if t := h.GetType(url); t != nil { + return t, nil + } + } + } + return nil, fmt.Errorf("type with url %s: %w", url, ErrNotFound) } empty := mt.New().Interface() - return urlType{t: reflect.TypeOf(empty).Elem(), isProto: true}, nil + return reflect.TypeOf(empty).Elem(), nil } func tryDereference(v interface{}) reflect.Type { diff --git a/contrib/tetragon-rthooks/vendor/github.com/containerd/typeurl/v2/types_gogo.go b/contrib/tetragon-rthooks/vendor/github.com/containerd/typeurl/v2/types_gogo.go new file mode 100644 index 00000000000..fa293323bef --- /dev/null +++ b/contrib/tetragon-rthooks/vendor/github.com/containerd/typeurl/v2/types_gogo.go @@ -0,0 +1,68 @@ +//go:build !no_gogo + +/* + Copyright The containerd Authors. + + 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 typeurl + +import ( + "reflect" + + gogoproto "github.com/gogo/protobuf/proto" +) + +func init() { + handlers = append(handlers, gogoHandler{}) +} + +type gogoHandler struct{} + +func (gogoHandler) Marshaller(v interface{}) func() ([]byte, error) { + pm, ok := v.(gogoproto.Message) + if !ok { + return nil + } + return func() ([]byte, error) { + return gogoproto.Marshal(pm) + } +} + +func (gogoHandler) Unmarshaller(v interface{}) func([]byte) error { + pm, ok := v.(gogoproto.Message) + if !ok { + return nil + } + + return func(dt []byte) error { + return gogoproto.Unmarshal(dt, pm) + } +} + +func (gogoHandler) TypeURL(v interface{}) string { + pm, ok := v.(gogoproto.Message) + if !ok { + return "" + } + return gogoproto.MessageName(pm) +} + +func (gogoHandler) GetType(url string) reflect.Type { + t := gogoproto.MessageType(url) + if t == nil { + return nil + } + return t.Elem() +} diff --git a/contrib/tetragon-rthooks/vendor/k8s.io/cri-api/pkg/apis/runtime/v1/api.pb.go b/contrib/tetragon-rthooks/vendor/k8s.io/cri-api/pkg/apis/runtime/v1/api.pb.go index 56bc7dbae7f..d9f51eb05d4 100644 --- a/contrib/tetragon-rthooks/vendor/k8s.io/cri-api/pkg/apis/runtime/v1/api.pb.go +++ b/contrib/tetragon-rthooks/vendor/k8s.io/cri-api/pkg/apis/runtime/v1/api.pb.go @@ -77,7 +77,7 @@ func (Protocol) EnumDescriptor() ([]byte, []int) { type MountPropagation int32 const ( - // No mount propagation ("private" in Linux terminology). + // No mount propagation ("rprivate" in Linux terminology). MountPropagation_PROPAGATION_PRIVATE MountPropagation = 0 // Mounts get propagated from the host to the container ("rslave" in Linux). MountPropagation_PROPAGATION_HOST_TO_CONTAINER MountPropagation = 1 @@ -155,6 +155,40 @@ func (NamespaceMode) EnumDescriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{2} } +// SupplementalGroupsPolicy defines how supplemental groups +// of the first container processes are calculated. +type SupplementalGroupsPolicy int32 + +const ( + // Merge means that the container's provided SupplementalGroups + // and FsGroup (specified in SecurityContext) will be merged with + // the primary user's groups as defined in the container image + // (in /etc/group). + SupplementalGroupsPolicy_Merge SupplementalGroupsPolicy = 0 + // Strict means that the container's provided SupplementalGroups + // and FsGroup (specified in SecurityContext) will be used instead of + // any groups defined in the container image. + SupplementalGroupsPolicy_Strict SupplementalGroupsPolicy = 1 +) + +var SupplementalGroupsPolicy_name = map[int32]string{ + 0: "Merge", + 1: "Strict", +} + +var SupplementalGroupsPolicy_value = map[string]int32{ + "Merge": 0, + "Strict": 1, +} + +func (x SupplementalGroupsPolicy) String() string { + return proto.EnumName(SupplementalGroupsPolicy_name, int32(x)) +} + +func (SupplementalGroupsPolicy) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_00212fb1f9d3bf1c, []int{3} +} + type PodSandboxState int32 const ( @@ -177,7 +211,7 @@ func (x PodSandboxState) String() string { } func (PodSandboxState) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{3} + return fileDescriptor_00212fb1f9d3bf1c, []int{4} } type ContainerState int32 @@ -208,7 +242,7 @@ func (x ContainerState) String() string { } func (ContainerState) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{4} + return fileDescriptor_00212fb1f9d3bf1c, []int{5} } type ContainerEventType int32 @@ -243,7 +277,7 @@ func (x ContainerEventType) String() string { } func (ContainerEventType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{5} + return fileDescriptor_00212fb1f9d3bf1c, []int{6} } type MetricType int32 @@ -268,7 +302,32 @@ func (x MetricType) String() string { } func (MetricType) EnumDescriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{6} + return fileDescriptor_00212fb1f9d3bf1c, []int{7} +} + +type CgroupDriver int32 + +const ( + CgroupDriver_SYSTEMD CgroupDriver = 0 + CgroupDriver_CGROUPFS CgroupDriver = 1 +) + +var CgroupDriver_name = map[int32]string{ + 0: "SYSTEMD", + 1: "CGROUPFS", +} + +var CgroupDriver_value = map[string]int32{ + "SYSTEMD": 0, + "CGROUPFS": 1, +} + +func (x CgroupDriver) String() string { + return proto.EnumName(CgroupDriver_name, int32(x)) +} + +func (CgroupDriver) EnumDescriptor() ([]byte, []int) { + return fileDescriptor_00212fb1f9d3bf1c, []int{8} } // Available profile types. @@ -581,9 +640,27 @@ type Mount struct { // UidMappings specifies the runtime UID mappings for the mount. UidMappings []*IDMapping `protobuf:"bytes,6,rep,name=uidMappings,proto3" json:"uidMappings,omitempty"` // GidMappings specifies the runtime GID mappings for the mount. - GidMappings []*IDMapping `protobuf:"bytes,7,rep,name=gidMappings,proto3" json:"gidMappings,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_sizecache int32 `json:"-"` + GidMappings []*IDMapping `protobuf:"bytes,7,rep,name=gidMappings,proto3" json:"gidMappings,omitempty"` + // If set to true, the mount is made recursive read-only. + // In this CRI API, recursive_read_only is a plain true/false boolean, although its equivalent + // in the Kubernetes core API is a quaternary that can be nil, "Enabled", "IfPossible", or "Disabled". + // kubelet translates that quaternary value in the core API into a boolean in this CRI API. + // Remarks: + // - nil is just treated as false + // - when set to true, readonly must be explicitly set to true, and propagation must be PRIVATE (0). + // - (readonly == false && recursive_read_only == false) does not make the mount read-only. + RecursiveReadOnly bool `protobuf:"varint,8,opt,name=recursive_read_only,json=recursiveReadOnly,proto3" json:"recursive_read_only,omitempty"` + // Mount an image reference (image ID, with or without digest), which is a + // special use case for image volume mounts. If this field is set, then + // host_path should be unset. All OCI mounts are per feature definition + // readonly. The kubelet does an PullImage RPC and evaluates the returned + // PullImageResponse.image_ref value, which is then set to the + // ImageSpec.image field. Runtimes are expected to mount the image as + // required. + // Introduced in the OCI Volume Source KEP: https://kep.k8s.io/4639 + Image *ImageSpec `protobuf:"bytes,9,opt,name=image,proto3" json:"image,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *Mount) Reset() { *m = Mount{} } @@ -667,6 +744,20 @@ func (m *Mount) GetGidMappings() []*IDMapping { return nil } +func (m *Mount) GetRecursiveReadOnly() bool { + if m != nil { + return m.RecursiveReadOnly + } + return false +} + +func (m *Mount) GetImage() *ImageSpec { + if m != nil { + return m.Image + } + return nil +} + // IDMapping describes host to container ID mappings for a pod sandbox. type IDMapping struct { // HostId is the id on the host. @@ -959,13 +1050,14 @@ type LinuxSandboxSecurityContext struct { RunAsGroup *Int64Value `protobuf:"bytes,8,opt,name=run_as_group,json=runAsGroup,proto3" json:"run_as_group,omitempty"` // If set, the root filesystem of the sandbox is read-only. ReadonlyRootfs bool `protobuf:"varint,4,opt,name=readonly_rootfs,json=readonlyRootfs,proto3" json:"readonly_rootfs,omitempty"` - // List of groups applied to the first process run in the sandbox, in - // addition to the sandbox's primary GID, and group memberships defined - // in the container image for the sandbox's primary UID of the container process. - // If the list is empty, no additional groups are added to any container. - // Note that group memberships defined in the container image for the sandbox's primary UID - // of the container process are still effective, even if they are not included in this list. + // List of groups applied to the first process run in each container. + // supplemental_groups_policy can control how groups will be calculated. SupplementalGroups []int64 `protobuf:"varint,5,rep,packed,name=supplemental_groups,json=supplementalGroups,proto3" json:"supplemental_groups,omitempty"` + // supplemental_groups_policy defines how supplemental groups of the first + // container processes are calculated. + // Valid values are "Merge" and "Strict". + // If not specified, "Merge" is used. + SupplementalGroupsPolicy SupplementalGroupsPolicy `protobuf:"varint,11,opt,name=supplemental_groups_policy,json=supplementalGroupsPolicy,proto3,enum=runtime.v1.SupplementalGroupsPolicy" json:"supplemental_groups_policy,omitempty"` // Indicates whether the sandbox will be asked to run a privileged // container. If a privileged container is to be executed within it, this // MUST be true. @@ -1062,6 +1154,13 @@ func (m *LinuxSandboxSecurityContext) GetSupplementalGroups() []int64 { return nil } +func (m *LinuxSandboxSecurityContext) GetSupplementalGroupsPolicy() SupplementalGroupsPolicy { + if m != nil { + return m.SupplementalGroupsPolicy + } + return SupplementalGroupsPolicy_Merge +} + func (m *LinuxSandboxSecurityContext) GetPrivileged() bool { if m != nil { return m.Privileged @@ -3461,9 +3560,16 @@ type ImageSpec struct { // Unstructured key-value map holding arbitrary metadata. // ImageSpec Annotations can be used to help the runtime target specific // images in multi-arch images. - Annotations map[string]string `protobuf:"bytes,2,rep,name=annotations,proto3" json:"annotations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_sizecache int32 `json:"-"` + Annotations map[string]string `protobuf:"bytes,2,rep,name=annotations,proto3" json:"annotations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + // The container image reference specified by the user (e.g. image[:tag] or digest). + // Only set if available within the RPC context. + UserSpecifiedImage string `protobuf:"bytes,18,opt,name=user_specified_image,json=userSpecifiedImage,proto3" json:"user_specified_image,omitempty"` + // Runtime handler to use for pulling the image. + // If the runtime handler is unknown, the request should be rejected. + // An empty string would select the default runtime handler. + RuntimeHandler string `protobuf:"bytes,19,opt,name=runtime_handler,json=runtimeHandler,proto3" json:"runtime_handler,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *ImageSpec) Reset() { *m = ImageSpec{} } @@ -3512,6 +3618,20 @@ func (m *ImageSpec) GetAnnotations() map[string]string { return nil } +func (m *ImageSpec) GetUserSpecifiedImage() string { + if m != nil { + return m.UserSpecifiedImage + } + return "" +} + +func (m *ImageSpec) GetRuntimeHandler() string { + if m != nil { + return m.RuntimeHandler + } + return "" +} + type KeyValue struct { Key string `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"` Value string `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"` @@ -3937,13 +4057,14 @@ type LinuxContainerSecurityContext struct { RunAsUsername string `protobuf:"bytes,6,opt,name=run_as_username,json=runAsUsername,proto3" json:"run_as_username,omitempty"` // If set, the root filesystem of the container is read-only. ReadonlyRootfs bool `protobuf:"varint,7,opt,name=readonly_rootfs,json=readonlyRootfs,proto3" json:"readonly_rootfs,omitempty"` - // List of groups applied to the first process run in the container, in - // addition to the container's primary GID, and group memberships defined - // in the container image for the container's primary UID of the container process. - // If the list is empty, no additional groups are added to any container. - // Note that group memberships defined in the container image for the container's primary UID - // of the container process are still effective, even if they are not included in this list. + // List of groups applied to the first process run in each container. + // supplemental_groups_policy can control how groups will be calculated. SupplementalGroups []int64 `protobuf:"varint,8,rep,packed,name=supplemental_groups,json=supplementalGroups,proto3" json:"supplemental_groups,omitempty"` + // supplemental_groups_policy defines how supplemental groups of the first + // container processes are calculated. + // Valid values are "Merge" and "Strict". + // If not specified, "Merge" is used. + SupplementalGroupsPolicy SupplementalGroupsPolicy `protobuf:"varint,17,opt,name=supplemental_groups_policy,json=supplementalGroupsPolicy,proto3,enum=runtime.v1.SupplementalGroupsPolicy" json:"supplemental_groups_policy,omitempty"` // no_new_privs defines if the flag for no_new_privs should be set on the // container. NoNewPrivs bool `protobuf:"varint,11,opt,name=no_new_privs,json=noNewPrivs,proto3" json:"no_new_privs,omitempty"` @@ -4071,6 +4192,13 @@ func (m *LinuxContainerSecurityContext) GetSupplementalGroups() []int64 { return nil } +func (m *LinuxContainerSecurityContext) GetSupplementalGroupsPolicy() SupplementalGroupsPolicy { + if m != nil { + return m.SupplementalGroupsPolicy + } + return SupplementalGroupsPolicy_Merge +} + func (m *LinuxContainerSecurityContext) GetNoNewPrivs() bool { if m != nil { return m.NoNewPrivs @@ -4179,6 +4307,70 @@ func (m *LinuxContainerConfig) GetSecurityContext() *LinuxContainerSecurityConte return nil } +type LinuxContainerUser struct { + // uid is the primary uid initially attached to the first process in the container + Uid int64 `protobuf:"varint,1,opt,name=uid,proto3" json:"uid,omitempty"` + // gid is the primary gid initially attached to the first process in the container + Gid int64 `protobuf:"varint,2,opt,name=gid,proto3" json:"gid,omitempty"` + // supplemental_groups are the supplemental groups initially attached to the first process in the container + SupplementalGroups []int64 `protobuf:"varint,3,rep,packed,name=supplemental_groups,json=supplementalGroups,proto3" json:"supplemental_groups,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *LinuxContainerUser) Reset() { *m = LinuxContainerUser{} } +func (*LinuxContainerUser) ProtoMessage() {} +func (*LinuxContainerUser) Descriptor() ([]byte, []int) { + return fileDescriptor_00212fb1f9d3bf1c, []int{55} +} +func (m *LinuxContainerUser) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LinuxContainerUser) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LinuxContainerUser.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *LinuxContainerUser) XXX_Merge(src proto.Message) { + xxx_messageInfo_LinuxContainerUser.Merge(m, src) +} +func (m *LinuxContainerUser) XXX_Size() int { + return m.Size() +} +func (m *LinuxContainerUser) XXX_DiscardUnknown() { + xxx_messageInfo_LinuxContainerUser.DiscardUnknown(m) +} + +var xxx_messageInfo_LinuxContainerUser proto.InternalMessageInfo + +func (m *LinuxContainerUser) GetUid() int64 { + if m != nil { + return m.Uid + } + return 0 +} + +func (m *LinuxContainerUser) GetGid() int64 { + if m != nil { + return m.Gid + } + return 0 +} + +func (m *LinuxContainerUser) GetSupplementalGroups() []int64 { + if m != nil { + return m.SupplementalGroups + } + return nil +} + // WindowsNamespaceOption provides options for Windows namespaces. type WindowsNamespaceOption struct { // Network namespace for this container/sandbox. @@ -4191,7 +4383,7 @@ type WindowsNamespaceOption struct { func (m *WindowsNamespaceOption) Reset() { *m = WindowsNamespaceOption{} } func (*WindowsNamespaceOption) ProtoMessage() {} func (*WindowsNamespaceOption) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{55} + return fileDescriptor_00212fb1f9d3bf1c, []int{56} } func (m *WindowsNamespaceOption) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4248,7 +4440,7 @@ type WindowsSandboxSecurityContext struct { func (m *WindowsSandboxSecurityContext) Reset() { *m = WindowsSandboxSecurityContext{} } func (*WindowsSandboxSecurityContext) ProtoMessage() {} func (*WindowsSandboxSecurityContext) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{56} + return fileDescriptor_00212fb1f9d3bf1c, []int{57} } func (m *WindowsSandboxSecurityContext) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4317,7 +4509,7 @@ type WindowsPodSandboxConfig struct { func (m *WindowsPodSandboxConfig) Reset() { *m = WindowsPodSandboxConfig{} } func (*WindowsPodSandboxConfig) ProtoMessage() {} func (*WindowsPodSandboxConfig) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{57} + return fileDescriptor_00212fb1f9d3bf1c, []int{58} } func (m *WindowsPodSandboxConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4370,7 +4562,7 @@ type WindowsContainerSecurityContext struct { func (m *WindowsContainerSecurityContext) Reset() { *m = WindowsContainerSecurityContext{} } func (*WindowsContainerSecurityContext) ProtoMessage() {} func (*WindowsContainerSecurityContext) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{58} + return fileDescriptor_00212fb1f9d3bf1c, []int{59} } func (m *WindowsContainerSecurityContext) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4434,7 +4626,7 @@ type WindowsContainerConfig struct { func (m *WindowsContainerConfig) Reset() { *m = WindowsContainerConfig{} } func (*WindowsContainerConfig) ProtoMessage() {} func (*WindowsContainerConfig) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{59} + return fileDescriptor_00212fb1f9d3bf1c, []int{60} } func (m *WindowsContainerConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4497,7 +4689,7 @@ type WindowsContainerResources struct { func (m *WindowsContainerResources) Reset() { *m = WindowsContainerResources{} } func (*WindowsContainerResources) ProtoMessage() {} func (*WindowsContainerResources) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{60} + return fileDescriptor_00212fb1f9d3bf1c, []int{61} } func (m *WindowsContainerResources) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4578,7 +4770,7 @@ type ContainerMetadata struct { func (m *ContainerMetadata) Reset() { *m = ContainerMetadata{} } func (*ContainerMetadata) ProtoMessage() {} func (*ContainerMetadata) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{61} + return fileDescriptor_00212fb1f9d3bf1c, []int{62} } func (m *ContainerMetadata) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4639,7 +4831,7 @@ type Device struct { func (m *Device) Reset() { *m = Device{} } func (*Device) ProtoMessage() {} func (*Device) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{62} + return fileDescriptor_00212fb1f9d3bf1c, []int{63} } func (m *Device) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4703,7 +4895,7 @@ type CDIDevice struct { func (m *CDIDevice) Reset() { *m = CDIDevice{} } func (*CDIDevice) ProtoMessage() {} func (*CDIDevice) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{63} + return fileDescriptor_00212fb1f9d3bf1c, []int{64} } func (m *CDIDevice) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4805,7 +4997,7 @@ type ContainerConfig struct { func (m *ContainerConfig) Reset() { *m = ContainerConfig{} } func (*ContainerConfig) ProtoMessage() {} func (*ContainerConfig) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{64} + return fileDescriptor_00212fb1f9d3bf1c, []int{65} } func (m *ContainerConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -4970,7 +5162,7 @@ type CreateContainerRequest struct { func (m *CreateContainerRequest) Reset() { *m = CreateContainerRequest{} } func (*CreateContainerRequest) ProtoMessage() {} func (*CreateContainerRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{65} + return fileDescriptor_00212fb1f9d3bf1c, []int{66} } func (m *CreateContainerRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5030,7 +5222,7 @@ type CreateContainerResponse struct { func (m *CreateContainerResponse) Reset() { *m = CreateContainerResponse{} } func (*CreateContainerResponse) ProtoMessage() {} func (*CreateContainerResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{66} + return fileDescriptor_00212fb1f9d3bf1c, []int{67} } func (m *CreateContainerResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5076,7 +5268,7 @@ type StartContainerRequest struct { func (m *StartContainerRequest) Reset() { *m = StartContainerRequest{} } func (*StartContainerRequest) ProtoMessage() {} func (*StartContainerRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{67} + return fileDescriptor_00212fb1f9d3bf1c, []int{68} } func (m *StartContainerRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5120,7 +5312,7 @@ type StartContainerResponse struct { func (m *StartContainerResponse) Reset() { *m = StartContainerResponse{} } func (*StartContainerResponse) ProtoMessage() {} func (*StartContainerResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{68} + return fileDescriptor_00212fb1f9d3bf1c, []int{69} } func (m *StartContainerResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5162,7 +5354,7 @@ type StopContainerRequest struct { func (m *StopContainerRequest) Reset() { *m = StopContainerRequest{} } func (*StopContainerRequest) ProtoMessage() {} func (*StopContainerRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{69} + return fileDescriptor_00212fb1f9d3bf1c, []int{70} } func (m *StopContainerRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5213,7 +5405,7 @@ type StopContainerResponse struct { func (m *StopContainerResponse) Reset() { *m = StopContainerResponse{} } func (*StopContainerResponse) ProtoMessage() {} func (*StopContainerResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{70} + return fileDescriptor_00212fb1f9d3bf1c, []int{71} } func (m *StopContainerResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5252,7 +5444,7 @@ type RemoveContainerRequest struct { func (m *RemoveContainerRequest) Reset() { *m = RemoveContainerRequest{} } func (*RemoveContainerRequest) ProtoMessage() {} func (*RemoveContainerRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{71} + return fileDescriptor_00212fb1f9d3bf1c, []int{72} } func (m *RemoveContainerRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5296,7 +5488,7 @@ type RemoveContainerResponse struct { func (m *RemoveContainerResponse) Reset() { *m = RemoveContainerResponse{} } func (*RemoveContainerResponse) ProtoMessage() {} func (*RemoveContainerResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{72} + return fileDescriptor_00212fb1f9d3bf1c, []int{73} } func (m *RemoveContainerResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5336,7 +5528,7 @@ type ContainerStateValue struct { func (m *ContainerStateValue) Reset() { *m = ContainerStateValue{} } func (*ContainerStateValue) ProtoMessage() {} func (*ContainerStateValue) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{73} + return fileDescriptor_00212fb1f9d3bf1c, []int{74} } func (m *ContainerStateValue) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5392,7 +5584,7 @@ type ContainerFilter struct { func (m *ContainerFilter) Reset() { *m = ContainerFilter{} } func (*ContainerFilter) ProtoMessage() {} func (*ContainerFilter) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{74} + return fileDescriptor_00212fb1f9d3bf1c, []int{75} } func (m *ContainerFilter) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5458,7 +5650,7 @@ type ListContainersRequest struct { func (m *ListContainersRequest) Reset() { *m = ListContainersRequest{} } func (*ListContainersRequest) ProtoMessage() {} func (*ListContainersRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{75} + return fileDescriptor_00212fb1f9d3bf1c, []int{76} } func (m *ListContainersRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5506,8 +5698,7 @@ type Container struct { Metadata *ContainerMetadata `protobuf:"bytes,3,opt,name=metadata,proto3" json:"metadata,omitempty"` // Spec of the image. Image *ImageSpec `protobuf:"bytes,4,opt,name=image,proto3" json:"image,omitempty"` - // Reference to the image in use. For most runtimes, this should be an - // image ID. + // Digested reference to the image in use. ImageRef string `protobuf:"bytes,5,opt,name=image_ref,json=imageRef,proto3" json:"image_ref,omitempty"` // State of the container. State ContainerState `protobuf:"varint,6,opt,name=state,proto3,enum=runtime.v1.ContainerState" json:"state,omitempty"` @@ -5519,15 +5710,25 @@ type Container struct { // Annotations MUST NOT be altered by the runtime; the value of this field // MUST be identical to that of the corresponding ContainerConfig used to // instantiate this Container. - Annotations map[string]string `protobuf:"bytes,9,rep,name=annotations,proto3" json:"annotations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_sizecache int32 `json:"-"` + Annotations map[string]string `protobuf:"bytes,9,rep,name=annotations,proto3" json:"annotations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + // Reference to the unique identifier of the image, on the node, as + // returned in the image service apis. + // + // Note: The image_ref above has been historically used by container + // runtimes to reference images by digest. The image_ref has been also used + // in the kubelet image garbage collection, which does not work with + // digests at all. To separate and avoid possible misusage, we now + // introduce the image_id field, which should always refer to a unique + // image identifier on the node. + ImageId string `protobuf:"bytes,10,opt,name=image_id,json=imageId,proto3" json:"image_id,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *Container) Reset() { *m = Container{} } func (*Container) ProtoMessage() {} func (*Container) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{76} + return fileDescriptor_00212fb1f9d3bf1c, []int{77} } func (m *Container) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5619,6 +5820,13 @@ func (m *Container) GetAnnotations() map[string]string { return nil } +func (m *Container) GetImageId() string { + if m != nil { + return m.ImageId + } + return "" +} + type ListContainersResponse struct { // List of containers. Containers []*Container `protobuf:"bytes,1,rep,name=containers,proto3" json:"containers,omitempty"` @@ -5629,7 +5837,7 @@ type ListContainersResponse struct { func (m *ListContainersResponse) Reset() { *m = ListContainersResponse{} } func (*ListContainersResponse) ProtoMessage() {} func (*ListContainersResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{77} + return fileDescriptor_00212fb1f9d3bf1c, []int{78} } func (m *ListContainersResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5677,7 +5885,7 @@ type ContainerStatusRequest struct { func (m *ContainerStatusRequest) Reset() { *m = ContainerStatusRequest{} } func (*ContainerStatusRequest) ProtoMessage() {} func (*ContainerStatusRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{78} + return fileDescriptor_00212fb1f9d3bf1c, []int{79} } func (m *ContainerStatusRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5738,8 +5946,7 @@ type ContainerStatus struct { ExitCode int32 `protobuf:"varint,7,opt,name=exit_code,json=exitCode,proto3" json:"exit_code,omitempty"` // Spec of the image. Image *ImageSpec `protobuf:"bytes,8,opt,name=image,proto3" json:"image,omitempty"` - // Reference to the image in use. For most runtimes, this should be an - // image ID + // Digested reference to the image in use. ImageRef string `protobuf:"bytes,9,opt,name=image_ref,json=imageRef,proto3" json:"image_ref,omitempty"` // Brief CamelCase string explaining why container is in its current state. // Must be set to "OOMKilled" for containers terminated by cgroup-based Out-of-Memory killer. @@ -5759,15 +5966,25 @@ type ContainerStatus struct { // Log path of container. LogPath string `protobuf:"bytes,15,opt,name=log_path,json=logPath,proto3" json:"log_path,omitempty"` // Resource limits configuration of the container. - Resources *ContainerResources `protobuf:"bytes,16,opt,name=resources,proto3" json:"resources,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_sizecache int32 `json:"-"` + Resources *ContainerResources `protobuf:"bytes,16,opt,name=resources,proto3" json:"resources,omitempty"` + // Reference to the unique identifier of the image, on the node, as + // returned in the image service apis. + // + // Note: The image_ref above has been historically used by container + // runtimes to reference images by digest. To separate and avoid possible + // misusage, we now introduce the image_id field, which should always refer + // to a unique image identifier on the node. + ImageId string `protobuf:"bytes,17,opt,name=image_id,json=imageId,proto3" json:"image_id,omitempty"` + // User identities initially attached to the container + User *ContainerUser `protobuf:"bytes,18,opt,name=user,proto3" json:"user,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *ContainerStatus) Reset() { *m = ContainerStatus{} } func (*ContainerStatus) ProtoMessage() {} func (*ContainerStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{79} + return fileDescriptor_00212fb1f9d3bf1c, []int{80} } func (m *ContainerStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5908,6 +6125,20 @@ func (m *ContainerStatus) GetResources() *ContainerResources { return nil } +func (m *ContainerStatus) GetImageId() string { + if m != nil { + return m.ImageId + } + return "" +} + +func (m *ContainerStatus) GetUser() *ContainerUser { + if m != nil { + return m.User + } + return nil +} + type ContainerStatusResponse struct { // Status of the container. Status *ContainerStatus `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` @@ -5923,7 +6154,7 @@ type ContainerStatusResponse struct { func (m *ContainerStatusResponse) Reset() { *m = ContainerStatusResponse{} } func (*ContainerStatusResponse) ProtoMessage() {} func (*ContainerStatusResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{80} + return fileDescriptor_00212fb1f9d3bf1c, []int{81} } func (m *ContainerStatusResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -5979,7 +6210,7 @@ type ContainerResources struct { func (m *ContainerResources) Reset() { *m = ContainerResources{} } func (*ContainerResources) ProtoMessage() {} func (*ContainerResources) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{81} + return fileDescriptor_00212fb1f9d3bf1c, []int{82} } func (m *ContainerResources) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6022,6 +6253,53 @@ func (m *ContainerResources) GetWindows() *WindowsContainerResources { return nil } +type ContainerUser struct { + // User identities initially attached to first process in the Linux container. + // Note that the actual running identity can be changed if the process has enough privilege to do so. + Linux *LinuxContainerUser `protobuf:"bytes,1,opt,name=linux,proto3" json:"linux,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *ContainerUser) Reset() { *m = ContainerUser{} } +func (*ContainerUser) ProtoMessage() {} +func (*ContainerUser) Descriptor() ([]byte, []int) { + return fileDescriptor_00212fb1f9d3bf1c, []int{83} +} +func (m *ContainerUser) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *ContainerUser) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_ContainerUser.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *ContainerUser) XXX_Merge(src proto.Message) { + xxx_messageInfo_ContainerUser.Merge(m, src) +} +func (m *ContainerUser) XXX_Size() int { + return m.Size() +} +func (m *ContainerUser) XXX_DiscardUnknown() { + xxx_messageInfo_ContainerUser.DiscardUnknown(m) +} + +var xxx_messageInfo_ContainerUser proto.InternalMessageInfo + +func (m *ContainerUser) GetLinux() *LinuxContainerUser { + if m != nil { + return m.Linux + } + return nil +} + type UpdateContainerResourcesRequest struct { // ID of the container to update. ContainerId string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` @@ -6040,7 +6318,7 @@ type UpdateContainerResourcesRequest struct { func (m *UpdateContainerResourcesRequest) Reset() { *m = UpdateContainerResourcesRequest{} } func (*UpdateContainerResourcesRequest) ProtoMessage() {} func (*UpdateContainerResourcesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{82} + return fileDescriptor_00212fb1f9d3bf1c, []int{84} } func (m *UpdateContainerResourcesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6105,7 +6383,7 @@ type UpdateContainerResourcesResponse struct { func (m *UpdateContainerResourcesResponse) Reset() { *m = UpdateContainerResourcesResponse{} } func (*UpdateContainerResourcesResponse) ProtoMessage() {} func (*UpdateContainerResourcesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{83} + return fileDescriptor_00212fb1f9d3bf1c, []int{85} } func (m *UpdateContainerResourcesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6148,7 +6426,7 @@ type ExecSyncRequest struct { func (m *ExecSyncRequest) Reset() { *m = ExecSyncRequest{} } func (*ExecSyncRequest) ProtoMessage() {} func (*ExecSyncRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{84} + return fileDescriptor_00212fb1f9d3bf1c, []int{86} } func (m *ExecSyncRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6220,7 +6498,7 @@ type ExecSyncResponse struct { func (m *ExecSyncResponse) Reset() { *m = ExecSyncResponse{} } func (*ExecSyncResponse) ProtoMessage() {} func (*ExecSyncResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{85} + return fileDescriptor_00212fb1f9d3bf1c, []int{87} } func (m *ExecSyncResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6296,7 +6574,7 @@ type ExecRequest struct { func (m *ExecRequest) Reset() { *m = ExecRequest{} } func (*ExecRequest) ProtoMessage() {} func (*ExecRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{86} + return fileDescriptor_00212fb1f9d3bf1c, []int{88} } func (m *ExecRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6377,7 +6655,7 @@ type ExecResponse struct { func (m *ExecResponse) Reset() { *m = ExecResponse{} } func (*ExecResponse) ProtoMessage() {} func (*ExecResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{87} + return fileDescriptor_00212fb1f9d3bf1c, []int{89} } func (m *ExecResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6438,7 +6716,7 @@ type AttachRequest struct { func (m *AttachRequest) Reset() { *m = AttachRequest{} } func (*AttachRequest) ProtoMessage() {} func (*AttachRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{88} + return fileDescriptor_00212fb1f9d3bf1c, []int{90} } func (m *AttachRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6512,7 +6790,7 @@ type AttachResponse struct { func (m *AttachResponse) Reset() { *m = AttachResponse{} } func (*AttachResponse) ProtoMessage() {} func (*AttachResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{89} + return fileDescriptor_00212fb1f9d3bf1c, []int{91} } func (m *AttachResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6560,7 +6838,7 @@ type PortForwardRequest struct { func (m *PortForwardRequest) Reset() { *m = PortForwardRequest{} } func (*PortForwardRequest) ProtoMessage() {} func (*PortForwardRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{90} + return fileDescriptor_00212fb1f9d3bf1c, []int{92} } func (m *PortForwardRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6613,7 +6891,7 @@ type PortForwardResponse struct { func (m *PortForwardResponse) Reset() { *m = PortForwardResponse{} } func (*PortForwardResponse) ProtoMessage() {} func (*PortForwardResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{91} + return fileDescriptor_00212fb1f9d3bf1c, []int{93} } func (m *PortForwardResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6659,7 +6937,7 @@ type ImageFilter struct { func (m *ImageFilter) Reset() { *m = ImageFilter{} } func (*ImageFilter) ProtoMessage() {} func (*ImageFilter) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{92} + return fileDescriptor_00212fb1f9d3bf1c, []int{94} } func (m *ImageFilter) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6705,7 +6983,7 @@ type ListImagesRequest struct { func (m *ListImagesRequest) Reset() { *m = ListImagesRequest{} } func (*ListImagesRequest) ProtoMessage() {} func (*ListImagesRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{93} + return fileDescriptor_00212fb1f9d3bf1c, []int{95} } func (m *ListImagesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6771,7 +7049,7 @@ type Image struct { func (m *Image) Reset() { *m = Image{} } func (*Image) ProtoMessage() {} func (*Image) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{94} + return fileDescriptor_00212fb1f9d3bf1c, []int{96} } func (m *Image) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6866,7 +7144,7 @@ type ListImagesResponse struct { func (m *ListImagesResponse) Reset() { *m = ListImagesResponse{} } func (*ListImagesResponse) ProtoMessage() {} func (*ListImagesResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{95} + return fileDescriptor_00212fb1f9d3bf1c, []int{97} } func (m *ListImagesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6914,7 +7192,7 @@ type ImageStatusRequest struct { func (m *ImageStatusRequest) Reset() { *m = ImageStatusRequest{} } func (*ImageStatusRequest) ProtoMessage() {} func (*ImageStatusRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{96} + return fileDescriptor_00212fb1f9d3bf1c, []int{98} } func (m *ImageStatusRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -6972,7 +7250,7 @@ type ImageStatusResponse struct { func (m *ImageStatusResponse) Reset() { *m = ImageStatusResponse{} } func (*ImageStatusResponse) ProtoMessage() {} func (*ImageStatusResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{97} + return fileDescriptor_00212fb1f9d3bf1c, []int{99} } func (m *ImageStatusResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7033,7 +7311,7 @@ type AuthConfig struct { func (m *AuthConfig) Reset() { *m = AuthConfig{} } func (*AuthConfig) ProtoMessage() {} func (*AuthConfig) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{98} + return fileDescriptor_00212fb1f9d3bf1c, []int{100} } func (m *AuthConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7118,7 +7396,7 @@ type PullImageRequest struct { func (m *PullImageRequest) Reset() { *m = PullImageRequest{} } func (*PullImageRequest) ProtoMessage() {} func (*PullImageRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{99} + return fileDescriptor_00212fb1f9d3bf1c, []int{101} } func (m *PullImageRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7179,7 +7457,7 @@ type PullImageResponse struct { func (m *PullImageResponse) Reset() { *m = PullImageResponse{} } func (*PullImageResponse) ProtoMessage() {} func (*PullImageResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{100} + return fileDescriptor_00212fb1f9d3bf1c, []int{102} } func (m *PullImageResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7225,7 +7503,7 @@ type RemoveImageRequest struct { func (m *RemoveImageRequest) Reset() { *m = RemoveImageRequest{} } func (*RemoveImageRequest) ProtoMessage() {} func (*RemoveImageRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{101} + return fileDescriptor_00212fb1f9d3bf1c, []int{103} } func (m *RemoveImageRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7269,7 +7547,7 @@ type RemoveImageResponse struct { func (m *RemoveImageResponse) Reset() { *m = RemoveImageResponse{} } func (*RemoveImageResponse) ProtoMessage() {} func (*RemoveImageResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{102} + return fileDescriptor_00212fb1f9d3bf1c, []int{104} } func (m *RemoveImageResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7309,7 +7587,7 @@ type NetworkConfig struct { func (m *NetworkConfig) Reset() { *m = NetworkConfig{} } func (*NetworkConfig) ProtoMessage() {} func (*NetworkConfig) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{103} + return fileDescriptor_00212fb1f9d3bf1c, []int{105} } func (m *NetworkConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7354,7 +7632,7 @@ type RuntimeConfig struct { func (m *RuntimeConfig) Reset() { *m = RuntimeConfig{} } func (*RuntimeConfig) ProtoMessage() {} func (*RuntimeConfig) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{104} + return fileDescriptor_00212fb1f9d3bf1c, []int{106} } func (m *RuntimeConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7399,7 +7677,7 @@ type UpdateRuntimeConfigRequest struct { func (m *UpdateRuntimeConfigRequest) Reset() { *m = UpdateRuntimeConfigRequest{} } func (*UpdateRuntimeConfigRequest) ProtoMessage() {} func (*UpdateRuntimeConfigRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{105} + return fileDescriptor_00212fb1f9d3bf1c, []int{107} } func (m *UpdateRuntimeConfigRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7443,7 +7721,7 @@ type UpdateRuntimeConfigResponse struct { func (m *UpdateRuntimeConfigResponse) Reset() { *m = UpdateRuntimeConfigResponse{} } func (*UpdateRuntimeConfigResponse) ProtoMessage() {} func (*UpdateRuntimeConfigResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{106} + return fileDescriptor_00212fb1f9d3bf1c, []int{108} } func (m *UpdateRuntimeConfigResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7502,7 +7780,7 @@ type RuntimeCondition struct { func (m *RuntimeCondition) Reset() { *m = RuntimeCondition{} } func (*RuntimeCondition) ProtoMessage() {} func (*RuntimeCondition) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{107} + return fileDescriptor_00212fb1f9d3bf1c, []int{109} } func (m *RuntimeCondition) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7570,7 +7848,7 @@ type RuntimeStatus struct { func (m *RuntimeStatus) Reset() { *m = RuntimeStatus{} } func (*RuntimeStatus) ProtoMessage() {} func (*RuntimeStatus) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{108} + return fileDescriptor_00212fb1f9d3bf1c, []int{110} } func (m *RuntimeStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7616,7 +7894,7 @@ type StatusRequest struct { func (m *StatusRequest) Reset() { *m = StatusRequest{} } func (*StatusRequest) ProtoMessage() {} func (*StatusRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{109} + return fileDescriptor_00212fb1f9d3bf1c, []int{111} } func (m *StatusRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7652,6 +7930,171 @@ func (m *StatusRequest) GetVerbose() bool { return false } +// RuntimeHandlerFeatures is a set of features implemented by the runtime handler. +type RuntimeHandlerFeatures struct { + // recursive_read_only_mounts is set to true if the runtime handler supports + // recursive read-only mounts. + // For runc-compatible runtimes, availability of this feature can be detected by checking whether + // the Linux kernel version is >= 5.12, and, `runc features | jq .mountOptions` contains "rro". + RecursiveReadOnlyMounts bool `protobuf:"varint,1,opt,name=recursive_read_only_mounts,json=recursiveReadOnlyMounts,proto3" json:"recursive_read_only_mounts,omitempty"` + // user_namespaces is set to true if the runtime handler supports user namespaces as implemented + // in Kubernetes. This means support for both, user namespaces and idmap mounts. + UserNamespaces bool `protobuf:"varint,2,opt,name=user_namespaces,json=userNamespaces,proto3" json:"user_namespaces,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RuntimeHandlerFeatures) Reset() { *m = RuntimeHandlerFeatures{} } +func (*RuntimeHandlerFeatures) ProtoMessage() {} +func (*RuntimeHandlerFeatures) Descriptor() ([]byte, []int) { + return fileDescriptor_00212fb1f9d3bf1c, []int{112} +} +func (m *RuntimeHandlerFeatures) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RuntimeHandlerFeatures) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RuntimeHandlerFeatures.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *RuntimeHandlerFeatures) XXX_Merge(src proto.Message) { + xxx_messageInfo_RuntimeHandlerFeatures.Merge(m, src) +} +func (m *RuntimeHandlerFeatures) XXX_Size() int { + return m.Size() +} +func (m *RuntimeHandlerFeatures) XXX_DiscardUnknown() { + xxx_messageInfo_RuntimeHandlerFeatures.DiscardUnknown(m) +} + +var xxx_messageInfo_RuntimeHandlerFeatures proto.InternalMessageInfo + +func (m *RuntimeHandlerFeatures) GetRecursiveReadOnlyMounts() bool { + if m != nil { + return m.RecursiveReadOnlyMounts + } + return false +} + +func (m *RuntimeHandlerFeatures) GetUserNamespaces() bool { + if m != nil { + return m.UserNamespaces + } + return false +} + +type RuntimeHandler struct { + // Name must be unique in StatusResponse. + // An empty string denotes the default handler. + Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` + // Supported features. + Features *RuntimeHandlerFeatures `protobuf:"bytes,2,opt,name=features,proto3" json:"features,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RuntimeHandler) Reset() { *m = RuntimeHandler{} } +func (*RuntimeHandler) ProtoMessage() {} +func (*RuntimeHandler) Descriptor() ([]byte, []int) { + return fileDescriptor_00212fb1f9d3bf1c, []int{113} +} +func (m *RuntimeHandler) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RuntimeHandler) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RuntimeHandler.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *RuntimeHandler) XXX_Merge(src proto.Message) { + xxx_messageInfo_RuntimeHandler.Merge(m, src) +} +func (m *RuntimeHandler) XXX_Size() int { + return m.Size() +} +func (m *RuntimeHandler) XXX_DiscardUnknown() { + xxx_messageInfo_RuntimeHandler.DiscardUnknown(m) +} + +var xxx_messageInfo_RuntimeHandler proto.InternalMessageInfo + +func (m *RuntimeHandler) GetName() string { + if m != nil { + return m.Name + } + return "" +} + +func (m *RuntimeHandler) GetFeatures() *RuntimeHandlerFeatures { + if m != nil { + return m.Features + } + return nil +} + +// RuntimeFeatures describes the set of features implemented by the CRI implementation. +// The features contained in the RuntimeFeatures should depend only on the cri implementation +// independent of runtime handlers. +type RuntimeFeatures struct { + // supplemental_groups_policy is set to true if the runtime supports SupplementalGroupsPolicy and ContainerUser. + SupplementalGroupsPolicy bool `protobuf:"varint,1,opt,name=supplemental_groups_policy,json=supplementalGroupsPolicy,proto3" json:"supplemental_groups_policy,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RuntimeFeatures) Reset() { *m = RuntimeFeatures{} } +func (*RuntimeFeatures) ProtoMessage() {} +func (*RuntimeFeatures) Descriptor() ([]byte, []int) { + return fileDescriptor_00212fb1f9d3bf1c, []int{114} +} +func (m *RuntimeFeatures) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RuntimeFeatures) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RuntimeFeatures.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *RuntimeFeatures) XXX_Merge(src proto.Message) { + xxx_messageInfo_RuntimeFeatures.Merge(m, src) +} +func (m *RuntimeFeatures) XXX_Size() int { + return m.Size() +} +func (m *RuntimeFeatures) XXX_DiscardUnknown() { + xxx_messageInfo_RuntimeFeatures.DiscardUnknown(m) +} + +var xxx_messageInfo_RuntimeFeatures proto.InternalMessageInfo + +func (m *RuntimeFeatures) GetSupplementalGroupsPolicy() bool { + if m != nil { + return m.SupplementalGroupsPolicy + } + return false +} + type StatusResponse struct { // Status of the Runtime. Status *RuntimeStatus `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` @@ -7659,15 +8102,20 @@ type StatusResponse struct { // value should be in json format. The information could include anything useful for // debug, e.g. plugins used by the container runtime. // It should only be returned non-empty when Verbose is true. - Info map[string]string `protobuf:"bytes,2,rep,name=info,proto3" json:"info,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_sizecache int32 `json:"-"` + Info map[string]string `protobuf:"bytes,2,rep,name=info,proto3" json:"info,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` + // Runtime handlers. + RuntimeHandlers []*RuntimeHandler `protobuf:"bytes,3,rep,name=runtime_handlers,json=runtimeHandlers,proto3" json:"runtime_handlers,omitempty"` + // features describes the set of features implemented by the CRI implementation. + // This field is supposed to propagate to NodeFeatures in Kubernetes API. + Features *RuntimeFeatures `protobuf:"bytes,4,opt,name=features,proto3" json:"features,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *StatusResponse) Reset() { *m = StatusResponse{} } func (*StatusResponse) ProtoMessage() {} func (*StatusResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{110} + return fileDescriptor_00212fb1f9d3bf1c, []int{115} } func (m *StatusResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7710,6 +8158,20 @@ func (m *StatusResponse) GetInfo() map[string]string { return nil } +func (m *StatusResponse) GetRuntimeHandlers() []*RuntimeHandler { + if m != nil { + return m.RuntimeHandlers + } + return nil +} + +func (m *StatusResponse) GetFeatures() *RuntimeFeatures { + if m != nil { + return m.Features + } + return nil +} + type ImageFsInfoRequest struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` @@ -7718,7 +8180,7 @@ type ImageFsInfoRequest struct { func (m *ImageFsInfoRequest) Reset() { *m = ImageFsInfoRequest{} } func (*ImageFsInfoRequest) ProtoMessage() {} func (*ImageFsInfoRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{111} + return fileDescriptor_00212fb1f9d3bf1c, []int{116} } func (m *ImageFsInfoRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7758,7 +8220,7 @@ type UInt64Value struct { func (m *UInt64Value) Reset() { *m = UInt64Value{} } func (*UInt64Value) ProtoMessage() {} func (*UInt64Value) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{112} + return fileDescriptor_00212fb1f9d3bf1c, []int{117} } func (m *UInt64Value) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7805,7 +8267,7 @@ type FilesystemIdentifier struct { func (m *FilesystemIdentifier) Reset() { *m = FilesystemIdentifier{} } func (*FilesystemIdentifier) ProtoMessage() {} func (*FilesystemIdentifier) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{113} + return fileDescriptor_00212fb1f9d3bf1c, []int{118} } func (m *FilesystemIdentifier) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7862,7 +8324,7 @@ type FilesystemUsage struct { func (m *FilesystemUsage) Reset() { *m = FilesystemUsage{} } func (*FilesystemUsage) ProtoMessage() {} func (*FilesystemUsage) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{114} + return fileDescriptor_00212fb1f9d3bf1c, []int{119} } func (m *FilesystemUsage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7936,7 +8398,7 @@ type WindowsFilesystemUsage struct { func (m *WindowsFilesystemUsage) Reset() { *m = WindowsFilesystemUsage{} } func (*WindowsFilesystemUsage) ProtoMessage() {} func (*WindowsFilesystemUsage) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{115} + return fileDescriptor_00212fb1f9d3bf1c, []int{120} } func (m *WindowsFilesystemUsage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -7988,7 +8450,12 @@ func (m *WindowsFilesystemUsage) GetUsedBytes() *UInt64Value { type ImageFsInfoResponse struct { // Information of image filesystem(s). - ImageFilesystems []*FilesystemUsage `protobuf:"bytes,1,rep,name=image_filesystems,json=imageFilesystems,proto3" json:"image_filesystems,omitempty"` + ImageFilesystems []*FilesystemUsage `protobuf:"bytes,1,rep,name=image_filesystems,json=imageFilesystems,proto3" json:"image_filesystems,omitempty"` + // Information of container filesystem(s). + // This is an optional field, may be used for example if container and image + // storage are separated. + // Default will be to return this as empty. + ContainerFilesystems []*FilesystemUsage `protobuf:"bytes,2,rep,name=container_filesystems,json=containerFilesystems,proto3" json:"container_filesystems,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } @@ -7996,7 +8463,7 @@ type ImageFsInfoResponse struct { func (m *ImageFsInfoResponse) Reset() { *m = ImageFsInfoResponse{} } func (*ImageFsInfoResponse) ProtoMessage() {} func (*ImageFsInfoResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{116} + return fileDescriptor_00212fb1f9d3bf1c, []int{121} } func (m *ImageFsInfoResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8032,6 +8499,13 @@ func (m *ImageFsInfoResponse) GetImageFilesystems() []*FilesystemUsage { return nil } +func (m *ImageFsInfoResponse) GetContainerFilesystems() []*FilesystemUsage { + if m != nil { + return m.ContainerFilesystems + } + return nil +} + type ContainerStatsRequest struct { // ID of the container for which to retrieve stats. ContainerId string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` @@ -8042,7 +8516,7 @@ type ContainerStatsRequest struct { func (m *ContainerStatsRequest) Reset() { *m = ContainerStatsRequest{} } func (*ContainerStatsRequest) ProtoMessage() {} func (*ContainerStatsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{117} + return fileDescriptor_00212fb1f9d3bf1c, []int{122} } func (m *ContainerStatsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8088,7 +8562,7 @@ type ContainerStatsResponse struct { func (m *ContainerStatsResponse) Reset() { *m = ContainerStatsResponse{} } func (*ContainerStatsResponse) ProtoMessage() {} func (*ContainerStatsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{118} + return fileDescriptor_00212fb1f9d3bf1c, []int{123} } func (m *ContainerStatsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8134,7 +8608,7 @@ type ListContainerStatsRequest struct { func (m *ListContainerStatsRequest) Reset() { *m = ListContainerStatsRequest{} } func (*ListContainerStatsRequest) ProtoMessage() {} func (*ListContainerStatsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{119} + return fileDescriptor_00212fb1f9d3bf1c, []int{124} } func (m *ListContainerStatsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8188,7 +8662,7 @@ type ContainerStatsFilter struct { func (m *ContainerStatsFilter) Reset() { *m = ContainerStatsFilter{} } func (*ContainerStatsFilter) ProtoMessage() {} func (*ContainerStatsFilter) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{120} + return fileDescriptor_00212fb1f9d3bf1c, []int{125} } func (m *ContainerStatsFilter) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8248,7 +8722,7 @@ type ListContainerStatsResponse struct { func (m *ListContainerStatsResponse) Reset() { *m = ListContainerStatsResponse{} } func (*ListContainerStatsResponse) ProtoMessage() {} func (*ListContainerStatsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{121} + return fileDescriptor_00212fb1f9d3bf1c, []int{126} } func (m *ListContainerStatsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8304,7 +8778,7 @@ type ContainerAttributes struct { func (m *ContainerAttributes) Reset() { *m = ContainerAttributes{} } func (*ContainerAttributes) ProtoMessage() {} func (*ContainerAttributes) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{122} + return fileDescriptor_00212fb1f9d3bf1c, []int{127} } func (m *ContainerAttributes) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8370,15 +8844,17 @@ type ContainerStats struct { // Memory usage gathered from the container. Memory *MemoryUsage `protobuf:"bytes,3,opt,name=memory,proto3" json:"memory,omitempty"` // Usage of the writable layer. - WritableLayer *FilesystemUsage `protobuf:"bytes,4,opt,name=writable_layer,json=writableLayer,proto3" json:"writable_layer,omitempty"` - XXX_NoUnkeyedLiteral struct{} `json:"-"` - XXX_sizecache int32 `json:"-"` + WritableLayer *FilesystemUsage `protobuf:"bytes,4,opt,name=writable_layer,json=writableLayer,proto3" json:"writable_layer,omitempty"` + // Swap usage gathered from the container. + Swap *SwapUsage `protobuf:"bytes,5,opt,name=swap,proto3" json:"swap,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_sizecache int32 `json:"-"` } func (m *ContainerStats) Reset() { *m = ContainerStats{} } func (*ContainerStats) ProtoMessage() {} func (*ContainerStats) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{123} + return fileDescriptor_00212fb1f9d3bf1c, []int{128} } func (m *ContainerStats) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8435,6 +8911,13 @@ func (m *ContainerStats) GetWritableLayer() *FilesystemUsage { return nil } +func (m *ContainerStats) GetSwap() *SwapUsage { + if m != nil { + return m.Swap + } + return nil +} + // WindowsContainerStats provides the resource usage statistics for a container specific for Windows type WindowsContainerStats struct { // Information of the container. @@ -8452,7 +8935,7 @@ type WindowsContainerStats struct { func (m *WindowsContainerStats) Reset() { *m = WindowsContainerStats{} } func (*WindowsContainerStats) ProtoMessage() {} func (*WindowsContainerStats) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{124} + return fileDescriptor_00212fb1f9d3bf1c, []int{129} } func (m *WindowsContainerStats) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8525,7 +9008,7 @@ type CpuUsage struct { func (m *CpuUsage) Reset() { *m = CpuUsage{} } func (*CpuUsage) ProtoMessage() {} func (*CpuUsage) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{125} + return fileDescriptor_00212fb1f9d3bf1c, []int{130} } func (m *CpuUsage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8591,7 +9074,7 @@ type WindowsCpuUsage struct { func (m *WindowsCpuUsage) Reset() { *m = WindowsCpuUsage{} } func (*WindowsCpuUsage) ProtoMessage() {} func (*WindowsCpuUsage) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{126} + return fileDescriptor_00212fb1f9d3bf1c, []int{131} } func (m *WindowsCpuUsage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8664,7 +9147,7 @@ type MemoryUsage struct { func (m *MemoryUsage) Reset() { *m = MemoryUsage{} } func (*MemoryUsage) ProtoMessage() {} func (*MemoryUsage) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{127} + return fileDescriptor_00212fb1f9d3bf1c, []int{132} } func (m *MemoryUsage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8742,16 +9225,82 @@ func (m *MemoryUsage) GetMajorPageFaults() *UInt64Value { return nil } +type SwapUsage struct { + // Timestamp in nanoseconds at which the information were collected. Must be > 0. + Timestamp int64 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"` + // Available swap for use. This is defined as the swap limit - swapUsageBytes. + SwapAvailableBytes *UInt64Value `protobuf:"bytes,2,opt,name=swap_available_bytes,json=swapAvailableBytes,proto3" json:"swap_available_bytes,omitempty"` + // Total memory in use. This includes all memory regardless of when it was accessed. + SwapUsageBytes *UInt64Value `protobuf:"bytes,3,opt,name=swap_usage_bytes,json=swapUsageBytes,proto3" json:"swap_usage_bytes,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *SwapUsage) Reset() { *m = SwapUsage{} } +func (*SwapUsage) ProtoMessage() {} +func (*SwapUsage) Descriptor() ([]byte, []int) { + return fileDescriptor_00212fb1f9d3bf1c, []int{133} +} +func (m *SwapUsage) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *SwapUsage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_SwapUsage.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *SwapUsage) XXX_Merge(src proto.Message) { + xxx_messageInfo_SwapUsage.Merge(m, src) +} +func (m *SwapUsage) XXX_Size() int { + return m.Size() +} +func (m *SwapUsage) XXX_DiscardUnknown() { + xxx_messageInfo_SwapUsage.DiscardUnknown(m) +} + +var xxx_messageInfo_SwapUsage proto.InternalMessageInfo + +func (m *SwapUsage) GetTimestamp() int64 { + if m != nil { + return m.Timestamp + } + return 0 +} + +func (m *SwapUsage) GetSwapAvailableBytes() *UInt64Value { + if m != nil { + return m.SwapAvailableBytes + } + return nil +} + +func (m *SwapUsage) GetSwapUsageBytes() *UInt64Value { + if m != nil { + return m.SwapUsageBytes + } + return nil +} + // WindowsMemoryUsage provides the memory usage information specific to Windows type WindowsMemoryUsage struct { // Timestamp in nanoseconds at which the information were collected. Must be > 0. Timestamp int64 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"` // The amount of working set memory in bytes. WorkingSetBytes *UInt64Value `protobuf:"bytes,2,opt,name=working_set_bytes,json=workingSetBytes,proto3" json:"working_set_bytes,omitempty"` - // Available memory for use. This is defined as the memory limit - workingSetBytes. + // Available memory for use. This is defined as the memory limit - commit_memory_bytes. AvailableBytes *UInt64Value `protobuf:"bytes,3,opt,name=available_bytes,json=availableBytes,proto3" json:"available_bytes,omitempty"` // Cumulative number of page faults. - PageFaults *UInt64Value `protobuf:"bytes,4,opt,name=page_faults,json=pageFaults,proto3" json:"page_faults,omitempty"` + PageFaults *UInt64Value `protobuf:"bytes,4,opt,name=page_faults,json=pageFaults,proto3" json:"page_faults,omitempty"` + // Total commit memory in use. Commit memory is total of physical and virtual memory in use. + CommitMemoryBytes *UInt64Value `protobuf:"bytes,5,opt,name=commit_memory_bytes,json=commitMemoryBytes,proto3" json:"commit_memory_bytes,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } @@ -8759,7 +9308,7 @@ type WindowsMemoryUsage struct { func (m *WindowsMemoryUsage) Reset() { *m = WindowsMemoryUsage{} } func (*WindowsMemoryUsage) ProtoMessage() {} func (*WindowsMemoryUsage) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{128} + return fileDescriptor_00212fb1f9d3bf1c, []int{134} } func (m *WindowsMemoryUsage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8816,6 +9365,13 @@ func (m *WindowsMemoryUsage) GetPageFaults() *UInt64Value { return nil } +func (m *WindowsMemoryUsage) GetCommitMemoryBytes() *UInt64Value { + if m != nil { + return m.CommitMemoryBytes + } + return nil +} + type ReopenContainerLogRequest struct { // ID of the container for which to reopen the log. ContainerId string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` @@ -8826,7 +9382,7 @@ type ReopenContainerLogRequest struct { func (m *ReopenContainerLogRequest) Reset() { *m = ReopenContainerLogRequest{} } func (*ReopenContainerLogRequest) ProtoMessage() {} func (*ReopenContainerLogRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{129} + return fileDescriptor_00212fb1f9d3bf1c, []int{135} } func (m *ReopenContainerLogRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8870,7 +9426,7 @@ type ReopenContainerLogResponse struct { func (m *ReopenContainerLogResponse) Reset() { *m = ReopenContainerLogResponse{} } func (*ReopenContainerLogResponse) ProtoMessage() {} func (*ReopenContainerLogResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{130} + return fileDescriptor_00212fb1f9d3bf1c, []int{136} } func (m *ReopenContainerLogResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8915,7 +9471,7 @@ type CheckpointContainerRequest struct { func (m *CheckpointContainerRequest) Reset() { *m = CheckpointContainerRequest{} } func (*CheckpointContainerRequest) ProtoMessage() {} func (*CheckpointContainerRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{131} + return fileDescriptor_00212fb1f9d3bf1c, []int{137} } func (m *CheckpointContainerRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -8973,7 +9529,7 @@ type CheckpointContainerResponse struct { func (m *CheckpointContainerResponse) Reset() { *m = CheckpointContainerResponse{} } func (*CheckpointContainerResponse) ProtoMessage() {} func (*CheckpointContainerResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{132} + return fileDescriptor_00212fb1f9d3bf1c, []int{138} } func (m *CheckpointContainerResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -9010,7 +9566,7 @@ type GetEventsRequest struct { func (m *GetEventsRequest) Reset() { *m = GetEventsRequest{} } func (*GetEventsRequest) ProtoMessage() {} func (*GetEventsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{133} + return fileDescriptor_00212fb1f9d3bf1c, []int{139} } func (m *GetEventsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -9057,7 +9613,7 @@ type ContainerEventResponse struct { func (m *ContainerEventResponse) Reset() { *m = ContainerEventResponse{} } func (*ContainerEventResponse) ProtoMessage() {} func (*ContainerEventResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{134} + return fileDescriptor_00212fb1f9d3bf1c, []int{140} } func (m *ContainerEventResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -9129,7 +9685,7 @@ type ListMetricDescriptorsRequest struct { func (m *ListMetricDescriptorsRequest) Reset() { *m = ListMetricDescriptorsRequest{} } func (*ListMetricDescriptorsRequest) ProtoMessage() {} func (*ListMetricDescriptorsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{135} + return fileDescriptor_00212fb1f9d3bf1c, []int{141} } func (m *ListMetricDescriptorsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -9167,7 +9723,7 @@ type ListMetricDescriptorsResponse struct { func (m *ListMetricDescriptorsResponse) Reset() { *m = ListMetricDescriptorsResponse{} } func (*ListMetricDescriptorsResponse) ProtoMessage() {} func (*ListMetricDescriptorsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{136} + return fileDescriptor_00212fb1f9d3bf1c, []int{142} } func (m *ListMetricDescriptorsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -9220,7 +9776,7 @@ type MetricDescriptor struct { func (m *MetricDescriptor) Reset() { *m = MetricDescriptor{} } func (*MetricDescriptor) ProtoMessage() {} func (*MetricDescriptor) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{137} + return fileDescriptor_00212fb1f9d3bf1c, []int{143} } func (m *MetricDescriptor) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -9278,7 +9834,7 @@ type ListPodSandboxMetricsRequest struct { func (m *ListPodSandboxMetricsRequest) Reset() { *m = ListPodSandboxMetricsRequest{} } func (*ListPodSandboxMetricsRequest) ProtoMessage() {} func (*ListPodSandboxMetricsRequest) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{138} + return fileDescriptor_00212fb1f9d3bf1c, []int{144} } func (m *ListPodSandboxMetricsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -9316,7 +9872,7 @@ type ListPodSandboxMetricsResponse struct { func (m *ListPodSandboxMetricsResponse) Reset() { *m = ListPodSandboxMetricsResponse{} } func (*ListPodSandboxMetricsResponse) ProtoMessage() {} func (*ListPodSandboxMetricsResponse) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{139} + return fileDescriptor_00212fb1f9d3bf1c, []int{145} } func (m *ListPodSandboxMetricsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -9363,7 +9919,7 @@ type PodSandboxMetrics struct { func (m *PodSandboxMetrics) Reset() { *m = PodSandboxMetrics{} } func (*PodSandboxMetrics) ProtoMessage() {} func (*PodSandboxMetrics) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{140} + return fileDescriptor_00212fb1f9d3bf1c, []int{146} } func (m *PodSandboxMetrics) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -9423,7 +9979,7 @@ type ContainerMetrics struct { func (m *ContainerMetrics) Reset() { *m = ContainerMetrics{} } func (*ContainerMetrics) ProtoMessage() {} func (*ContainerMetrics) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{141} + return fileDescriptor_00212fb1f9d3bf1c, []int{147} } func (m *ContainerMetrics) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -9486,7 +10042,7 @@ type Metric struct { func (m *Metric) Reset() { *m = Metric{} } func (*Metric) ProtoMessage() {} func (*Metric) Descriptor() ([]byte, []int) { - return fileDescriptor_00212fb1f9d3bf1c, []int{142} + return fileDescriptor_00212fb1f9d3bf1c, []int{148} } func (m *Metric) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) @@ -9550,14 +10106,153 @@ func (m *Metric) GetValue() *UInt64Value { return nil } +type RuntimeConfigRequest struct { + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RuntimeConfigRequest) Reset() { *m = RuntimeConfigRequest{} } +func (*RuntimeConfigRequest) ProtoMessage() {} +func (*RuntimeConfigRequest) Descriptor() ([]byte, []int) { + return fileDescriptor_00212fb1f9d3bf1c, []int{149} +} +func (m *RuntimeConfigRequest) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RuntimeConfigRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RuntimeConfigRequest.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *RuntimeConfigRequest) XXX_Merge(src proto.Message) { + xxx_messageInfo_RuntimeConfigRequest.Merge(m, src) +} +func (m *RuntimeConfigRequest) XXX_Size() int { + return m.Size() +} +func (m *RuntimeConfigRequest) XXX_DiscardUnknown() { + xxx_messageInfo_RuntimeConfigRequest.DiscardUnknown(m) +} + +var xxx_messageInfo_RuntimeConfigRequest proto.InternalMessageInfo + +type RuntimeConfigResponse struct { + // Configuration information for Linux-based runtimes. This field contains + // global runtime configuration options that are not specific to runtime + // handlers. + Linux *LinuxRuntimeConfiguration `protobuf:"bytes,1,opt,name=linux,proto3" json:"linux,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *RuntimeConfigResponse) Reset() { *m = RuntimeConfigResponse{} } +func (*RuntimeConfigResponse) ProtoMessage() {} +func (*RuntimeConfigResponse) Descriptor() ([]byte, []int) { + return fileDescriptor_00212fb1f9d3bf1c, []int{150} +} +func (m *RuntimeConfigResponse) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *RuntimeConfigResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_RuntimeConfigResponse.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *RuntimeConfigResponse) XXX_Merge(src proto.Message) { + xxx_messageInfo_RuntimeConfigResponse.Merge(m, src) +} +func (m *RuntimeConfigResponse) XXX_Size() int { + return m.Size() +} +func (m *RuntimeConfigResponse) XXX_DiscardUnknown() { + xxx_messageInfo_RuntimeConfigResponse.DiscardUnknown(m) +} + +var xxx_messageInfo_RuntimeConfigResponse proto.InternalMessageInfo + +func (m *RuntimeConfigResponse) GetLinux() *LinuxRuntimeConfiguration { + if m != nil { + return m.Linux + } + return nil +} + +type LinuxRuntimeConfiguration struct { + // Cgroup driver to use + // Note: this field should not change for the lifecycle of the Kubelet, + // or while there are running containers. + // The Kubelet will not re-request this after startup, and will construct the cgroup + // hierarchy assuming it is static. + // If the runtime wishes to change this value, it must be accompanied by removal of + // all pods, and a restart of the Kubelet. The easiest way to do this is with a full node reboot. + CgroupDriver CgroupDriver `protobuf:"varint,1,opt,name=cgroup_driver,json=cgroupDriver,proto3,enum=runtime.v1.CgroupDriver" json:"cgroup_driver,omitempty"` + XXX_NoUnkeyedLiteral struct{} `json:"-"` + XXX_sizecache int32 `json:"-"` +} + +func (m *LinuxRuntimeConfiguration) Reset() { *m = LinuxRuntimeConfiguration{} } +func (*LinuxRuntimeConfiguration) ProtoMessage() {} +func (*LinuxRuntimeConfiguration) Descriptor() ([]byte, []int) { + return fileDescriptor_00212fb1f9d3bf1c, []int{151} +} +func (m *LinuxRuntimeConfiguration) XXX_Unmarshal(b []byte) error { + return m.Unmarshal(b) +} +func (m *LinuxRuntimeConfiguration) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { + if deterministic { + return xxx_messageInfo_LinuxRuntimeConfiguration.Marshal(b, m, deterministic) + } else { + b = b[:cap(b)] + n, err := m.MarshalToSizedBuffer(b) + if err != nil { + return nil, err + } + return b[:n], nil + } +} +func (m *LinuxRuntimeConfiguration) XXX_Merge(src proto.Message) { + xxx_messageInfo_LinuxRuntimeConfiguration.Merge(m, src) +} +func (m *LinuxRuntimeConfiguration) XXX_Size() int { + return m.Size() +} +func (m *LinuxRuntimeConfiguration) XXX_DiscardUnknown() { + xxx_messageInfo_LinuxRuntimeConfiguration.DiscardUnknown(m) +} + +var xxx_messageInfo_LinuxRuntimeConfiguration proto.InternalMessageInfo + +func (m *LinuxRuntimeConfiguration) GetCgroupDriver() CgroupDriver { + if m != nil { + return m.CgroupDriver + } + return CgroupDriver_SYSTEMD +} + func init() { proto.RegisterEnum("runtime.v1.Protocol", Protocol_name, Protocol_value) proto.RegisterEnum("runtime.v1.MountPropagation", MountPropagation_name, MountPropagation_value) proto.RegisterEnum("runtime.v1.NamespaceMode", NamespaceMode_name, NamespaceMode_value) + proto.RegisterEnum("runtime.v1.SupplementalGroupsPolicy", SupplementalGroupsPolicy_name, SupplementalGroupsPolicy_value) proto.RegisterEnum("runtime.v1.PodSandboxState", PodSandboxState_name, PodSandboxState_value) proto.RegisterEnum("runtime.v1.ContainerState", ContainerState_name, ContainerState_value) proto.RegisterEnum("runtime.v1.ContainerEventType", ContainerEventType_name, ContainerEventType_value) proto.RegisterEnum("runtime.v1.MetricType", MetricType_name, MetricType_value) + proto.RegisterEnum("runtime.v1.CgroupDriver", CgroupDriver_name, CgroupDriver_value) proto.RegisterEnum("runtime.v1.SecurityProfile_ProfileType", SecurityProfile_ProfileType_name, SecurityProfile_ProfileType_value) proto.RegisterType((*VersionRequest)(nil), "runtime.v1.VersionRequest") proto.RegisterType((*VersionResponse)(nil), "runtime.v1.VersionResponse") @@ -9628,6 +10323,7 @@ func init() { proto.RegisterType((*Capability)(nil), "runtime.v1.Capability") proto.RegisterType((*LinuxContainerSecurityContext)(nil), "runtime.v1.LinuxContainerSecurityContext") proto.RegisterType((*LinuxContainerConfig)(nil), "runtime.v1.LinuxContainerConfig") + proto.RegisterType((*LinuxContainerUser)(nil), "runtime.v1.LinuxContainerUser") proto.RegisterType((*WindowsNamespaceOption)(nil), "runtime.v1.WindowsNamespaceOption") proto.RegisterType((*WindowsSandboxSecurityContext)(nil), "runtime.v1.WindowsSandboxSecurityContext") proto.RegisterType((*WindowsPodSandboxConfig)(nil), "runtime.v1.WindowsPodSandboxConfig") @@ -9663,6 +10359,7 @@ func init() { proto.RegisterType((*ContainerStatusResponse)(nil), "runtime.v1.ContainerStatusResponse") proto.RegisterMapType((map[string]string)(nil), "runtime.v1.ContainerStatusResponse.InfoEntry") proto.RegisterType((*ContainerResources)(nil), "runtime.v1.ContainerResources") + proto.RegisterType((*ContainerUser)(nil), "runtime.v1.ContainerUser") proto.RegisterType((*UpdateContainerResourcesRequest)(nil), "runtime.v1.UpdateContainerResourcesRequest") proto.RegisterMapType((map[string]string)(nil), "runtime.v1.UpdateContainerResourcesRequest.AnnotationsEntry") proto.RegisterType((*UpdateContainerResourcesResponse)(nil), "runtime.v1.UpdateContainerResourcesResponse") @@ -9693,6 +10390,9 @@ func init() { proto.RegisterType((*RuntimeCondition)(nil), "runtime.v1.RuntimeCondition") proto.RegisterType((*RuntimeStatus)(nil), "runtime.v1.RuntimeStatus") proto.RegisterType((*StatusRequest)(nil), "runtime.v1.StatusRequest") + proto.RegisterType((*RuntimeHandlerFeatures)(nil), "runtime.v1.RuntimeHandlerFeatures") + proto.RegisterType((*RuntimeHandler)(nil), "runtime.v1.RuntimeHandler") + proto.RegisterType((*RuntimeFeatures)(nil), "runtime.v1.RuntimeFeatures") proto.RegisterType((*StatusResponse)(nil), "runtime.v1.StatusResponse") proto.RegisterMapType((map[string]string)(nil), "runtime.v1.StatusResponse.InfoEntry") proto.RegisterType((*ImageFsInfoRequest)(nil), "runtime.v1.ImageFsInfoRequest") @@ -9715,6 +10415,7 @@ func init() { proto.RegisterType((*CpuUsage)(nil), "runtime.v1.CpuUsage") proto.RegisterType((*WindowsCpuUsage)(nil), "runtime.v1.WindowsCpuUsage") proto.RegisterType((*MemoryUsage)(nil), "runtime.v1.MemoryUsage") + proto.RegisterType((*SwapUsage)(nil), "runtime.v1.SwapUsage") proto.RegisterType((*WindowsMemoryUsage)(nil), "runtime.v1.WindowsMemoryUsage") proto.RegisterType((*ReopenContainerLogRequest)(nil), "runtime.v1.ReopenContainerLogRequest") proto.RegisterType((*ReopenContainerLogResponse)(nil), "runtime.v1.ReopenContainerLogResponse") @@ -9730,425 +10431,461 @@ func init() { proto.RegisterType((*PodSandboxMetrics)(nil), "runtime.v1.PodSandboxMetrics") proto.RegisterType((*ContainerMetrics)(nil), "runtime.v1.ContainerMetrics") proto.RegisterType((*Metric)(nil), "runtime.v1.Metric") + proto.RegisterType((*RuntimeConfigRequest)(nil), "runtime.v1.RuntimeConfigRequest") + proto.RegisterType((*RuntimeConfigResponse)(nil), "runtime.v1.RuntimeConfigResponse") + proto.RegisterType((*LinuxRuntimeConfiguration)(nil), "runtime.v1.LinuxRuntimeConfiguration") } func init() { proto.RegisterFile("api.proto", fileDescriptor_00212fb1f9d3bf1c) } var fileDescriptor_00212fb1f9d3bf1c = []byte{ - // 6593 bytes of a gzipped FileDescriptorProto - 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x7d, 0x4d, 0x6c, 0x1c, 0xc9, - 0x75, 0x30, 0x7b, 0x66, 0x48, 0xce, 0xbc, 0xe1, 0x90, 0xc3, 0x12, 0x45, 0x52, 0x43, 0x89, 0x92, - 0x7a, 0xff, 0xf4, 0xb3, 0xfa, 0x59, 0xad, 0x76, 0x57, 0x92, 0xb5, 0xbb, 0x1a, 0x91, 0x5c, 0x69, - 0xd6, 0x12, 0x39, 0x6e, 0x92, 0xb2, 0xd7, 0xfe, 0xe0, 0xfe, 0x5a, 0xd3, 0xc5, 0x61, 0xaf, 0x66, - 0xba, 0xdb, 0xdd, 0x3d, 0x92, 0xe8, 0x53, 0x8e, 0x89, 0x4f, 0x06, 0x12, 0xc7, 0x80, 0x11, 0x24, - 0xc8, 0x21, 0x3f, 0x40, 0x0e, 0x09, 0x02, 0x24, 0x70, 0x10, 0x24, 0x01, 0x8c, 0xc4, 0x70, 0x02, - 0x04, 0xc8, 0x21, 0x01, 0x7c, 0x08, 0x10, 0x7b, 0x13, 0x20, 0x40, 0x0e, 0xb9, 0xc4, 0x87, 0xdc, - 0x1c, 0xd4, 0x5f, 0x77, 0x57, 0xff, 0xcc, 0x0c, 0xb9, 0xeb, 0xdd, 0xf5, 0x89, 0xd3, 0xaf, 0xde, - 0x7b, 0xf5, 0xea, 0xd5, 0xab, 0x57, 0xaf, 0xaa, 0x5e, 0x15, 0xa1, 0x62, 0xb8, 0xd6, 0x65, 0xd7, - 0x73, 0x02, 0x07, 0x81, 0x37, 0xb0, 0x03, 0xab, 0x8f, 0x2f, 0x3f, 0x7d, 0xad, 0x71, 0xa9, 0x6b, - 0x05, 0xfb, 0x83, 0xc7, 0x97, 0x3b, 0x4e, 0xff, 0x4a, 0xd7, 0xe9, 0x3a, 0x57, 0x28, 0xca, 0xe3, - 0xc1, 0x1e, 0xfd, 0xa2, 0x1f, 0xf4, 0x17, 0x23, 0x55, 0x2f, 0xc0, 0xec, 0x23, 0xec, 0xf9, 0x96, - 0x63, 0x6b, 0xf8, 0x1b, 0x03, 0xec, 0x07, 0x68, 0x19, 0xa6, 0x9f, 0x32, 0xc8, 0xb2, 0x72, 0x46, - 0x39, 0x57, 0xd1, 0xc4, 0xa7, 0xfa, 0x07, 0x0a, 0xcc, 0x85, 0xc8, 0xbe, 0xeb, 0xd8, 0x3e, 0xce, - 0xc7, 0x46, 0x67, 0x61, 0x86, 0x8b, 0xa5, 0xdb, 0x46, 0x1f, 0x2f, 0x17, 0x68, 0x71, 0x95, 0xc3, - 0x36, 0x8d, 0x3e, 0x46, 0xaf, 0xc0, 0x9c, 0x40, 0x11, 0x4c, 0x8a, 0x14, 0x6b, 0x96, 0x83, 0x79, - 0x6d, 0xe8, 0x32, 0x1c, 0x13, 0x88, 0x86, 0x6b, 0x85, 0xc8, 0x25, 0x8a, 0x3c, 0xcf, 0x8b, 0x9a, - 0xae, 0xc5, 0xf1, 0xd5, 0xaf, 0x41, 0x65, 0x7d, 0x73, 0x7b, 0xcd, 0xb1, 0xf7, 0xac, 0x2e, 0x11, - 0xd1, 0xc7, 0x1e, 0xa1, 0x59, 0x56, 0xce, 0x14, 0x89, 0x88, 0xfc, 0x13, 0x35, 0xa0, 0xec, 0x63, - 0xc3, 0xeb, 0xec, 0x63, 0x7f, 0xb9, 0x40, 0x8b, 0xc2, 0x6f, 0x42, 0xe5, 0xb8, 0x81, 0xe5, 0xd8, - 0xfe, 0x72, 0x91, 0x51, 0xf1, 0x4f, 0xf5, 0xb7, 0x14, 0xa8, 0xb6, 0x1d, 0x2f, 0x78, 0x68, 0xb8, - 0xae, 0x65, 0x77, 0xd1, 0x55, 0x28, 0x53, 0x5d, 0x76, 0x9c, 0x1e, 0xd5, 0xc1, 0xec, 0xb5, 0x85, - 0xcb, 0x51, 0x87, 0x5c, 0x6e, 0xf3, 0x32, 0x2d, 0xc4, 0x42, 0x2f, 0xc1, 0x6c, 0xc7, 0xb1, 0x03, - 0xc3, 0xb2, 0xb1, 0xa7, 0xbb, 0x8e, 0x17, 0x50, 0xe5, 0x4c, 0x6a, 0xb5, 0x10, 0x4a, 0xf8, 0xa3, - 0x15, 0xa8, 0xec, 0x3b, 0x7e, 0xc0, 0x30, 0x8a, 0x14, 0xa3, 0x4c, 0x00, 0xb4, 0x70, 0x09, 0xa6, - 0x69, 0xa1, 0xe5, 0x72, 0x35, 0x4c, 0x91, 0xcf, 0x96, 0xab, 0xfe, 0xa0, 0x00, 0x93, 0x0f, 0x9d, - 0x81, 0x1d, 0x24, 0xaa, 0x31, 0x82, 0x7d, 0xde, 0x45, 0xb1, 0x6a, 0x8c, 0x60, 0x3f, 0xaa, 0x86, - 0x60, 0xb0, 0x5e, 0x62, 0xd5, 0x90, 0xc2, 0x06, 0x94, 0x3d, 0x6c, 0x98, 0x8e, 0xdd, 0x3b, 0xa0, - 0x22, 0x94, 0xb5, 0xf0, 0x9b, 0x74, 0x9f, 0x8f, 0x7b, 0x96, 0x3d, 0x78, 0xae, 0x7b, 0xb8, 0x67, - 0x3c, 0xc6, 0x3d, 0x2a, 0x4a, 0x59, 0x9b, 0xe5, 0x60, 0x8d, 0x41, 0xd1, 0x3b, 0x50, 0x75, 0x3d, - 0xc7, 0x35, 0xba, 0x06, 0xd1, 0xe0, 0xf2, 0x24, 0x55, 0xd2, 0xc9, 0xb8, 0x92, 0xa8, 0xc0, 0xed, - 0x08, 0x47, 0x8b, 0x13, 0xa0, 0xb7, 0xa0, 0x3a, 0xb0, 0x4c, 0xae, 0x6f, 0x7f, 0x79, 0xea, 0x4c, - 0xf1, 0x5c, 0xf5, 0xda, 0xf1, 0x38, 0x7d, 0x6b, 0x9d, 0x97, 0x6a, 0x71, 0x4c, 0x42, 0xd8, 0x8d, - 0x11, 0x4e, 0x0f, 0x25, 0x8c, 0x61, 0xaa, 0x3a, 0x54, 0xc2, 0x92, 0x48, 0xd5, 0x26, 0x55, 0x60, - 0x8d, 0xab, 0xda, 0x24, 0x26, 0x1e, 0x29, 0xd8, 0x32, 0xa9, 0xf2, 0x6a, 0x5a, 0x35, 0x84, 0xb5, - 0x4c, 0xb4, 0x08, 0x53, 0x3d, 0x6c, 0x77, 0x83, 0x7d, 0xaa, 0xbd, 0x9a, 0xc6, 0xbf, 0xd4, 0xdf, - 0x50, 0xa0, 0xb6, 0xeb, 0x63, 0x8f, 0x8c, 0x03, 0xdf, 0x35, 0x3a, 0x18, 0x5d, 0x82, 0x52, 0xdf, - 0x31, 0x31, 0x37, 0xa1, 0x13, 0x71, 0x21, 0x43, 0xa4, 0x87, 0x8e, 0x89, 0x35, 0x8a, 0x86, 0xce, - 0x43, 0x69, 0x60, 0x99, 0xcc, 0x6e, 0x73, 0xdb, 0x44, 0x51, 0x08, 0x6a, 0x97, 0xa0, 0x16, 0x87, - 0xa2, 0x12, 0x14, 0xf5, 0xe7, 0x0a, 0xcc, 0x85, 0xb5, 0x6d, 0x51, 0x83, 0x47, 0xaf, 0xc3, 0xb4, - 0x8d, 0x83, 0x67, 0x8e, 0xf7, 0x64, 0xb4, 0x6c, 0x02, 0x13, 0x5d, 0x84, 0xa2, 0xcb, 0x35, 0x32, - 0x94, 0x80, 0x60, 0x11, 0x64, 0xcb, 0xed, 0x50, 0x0d, 0x0d, 0x47, 0xb6, 0xdc, 0x0e, 0x31, 0xd7, - 0xc0, 0xf0, 0xba, 0x98, 0xf6, 0x07, 0x33, 0xfd, 0x32, 0x03, 0xb4, 0x4c, 0x74, 0x07, 0x66, 0x07, - 0x3e, 0xf6, 0x6c, 0x5f, 0x17, 0x83, 0x97, 0x18, 0x5b, 0x55, 0x66, 0x2a, 0xe9, 0x5d, 0xab, 0x31, - 0x82, 0x2d, 0x3e, 0xba, 0x55, 0x80, 0x96, 0x1d, 0xbc, 0x79, 0xfd, 0x91, 0xd1, 0x1b, 0x60, 0xb4, - 0x00, 0x93, 0x4f, 0xc9, 0x0f, 0xda, 0xf2, 0xa2, 0xc6, 0x3e, 0xd4, 0xbf, 0x2a, 0xc1, 0xca, 0x03, - 0x62, 0xe0, 0xdb, 0x86, 0x6d, 0x3e, 0x76, 0x9e, 0x6f, 0xe3, 0xce, 0xc0, 0xb3, 0x82, 0x83, 0x35, - 0xc7, 0x0e, 0xf0, 0xf3, 0x00, 0xdd, 0x87, 0x79, 0x5b, 0xf0, 0x0f, 0x05, 0x51, 0xa8, 0x20, 0x2b, - 0x99, 0xad, 0x63, 0x95, 0x6b, 0x75, 0x5b, 0x06, 0xf8, 0xe8, 0x6e, 0x34, 0xc4, 0x04, 0x9f, 0x42, - 0xba, 0x41, 0xdb, 0x1b, 0x54, 0x1a, 0xce, 0x45, 0x8c, 0x3e, 0xc1, 0xe3, 0x4d, 0x20, 0x4e, 0x57, - 0x37, 0x7c, 0x9d, 0xb4, 0x94, 0x6a, 0xb9, 0x7a, 0x6d, 0x51, 0xb2, 0x82, 0xb0, 0xc1, 0x5a, 0xc5, - 0x1b, 0xd8, 0x4d, 0x9f, 0x68, 0x08, 0xdd, 0xa0, 0x0e, 0x9c, 0xd0, 0x75, 0x3d, 0x67, 0xe0, 0x2e, - 0x97, 0x87, 0x12, 0x02, 0x25, 0xbc, 0x47, 0x30, 0xa9, 0x5f, 0xe7, 0x4e, 0x42, 0xf7, 0x1c, 0x27, - 0xd8, 0xf3, 0x85, 0x63, 0x10, 0x60, 0x8d, 0x42, 0xd1, 0x15, 0x38, 0xe6, 0x0f, 0x5c, 0xb7, 0x87, - 0xfb, 0xd8, 0x0e, 0x8c, 0x1e, 0xab, 0x88, 0xf4, 0x59, 0xf1, 0x5c, 0x51, 0x43, 0xf1, 0x22, 0xca, - 0xd8, 0x47, 0xab, 0x00, 0xae, 0x67, 0x3d, 0xb5, 0x7a, 0xb8, 0x8b, 0xcd, 0xe5, 0x29, 0xca, 0x34, - 0x06, 0x41, 0x6f, 0x10, 0x5f, 0xdf, 0xe9, 0x38, 0x7d, 0x77, 0xb9, 0x92, 0xd6, 0xb7, 0xe8, 0xa7, - 0xb6, 0xe7, 0xec, 0x59, 0x3d, 0xac, 0x09, 0x5c, 0xf4, 0x16, 0x94, 0x0d, 0xd7, 0x35, 0xbc, 0xbe, - 0xe3, 0x2d, 0xc3, 0x68, 0xba, 0x10, 0x19, 0x5d, 0x87, 0x05, 0xce, 0x43, 0x77, 0x59, 0x21, 0x73, - 0xa3, 0xd3, 0xc4, 0x2e, 0xef, 0x16, 0x96, 0x15, 0x0d, 0xf1, 0x72, 0x4e, 0x4b, 0x9c, 0xaa, 0xfa, - 0xb7, 0x0a, 0xcc, 0x25, 0x78, 0xa2, 0xf7, 0x61, 0x46, 0x70, 0x08, 0x0e, 0x5c, 0xe1, 0x06, 0x5e, - 0x19, 0x22, 0xc6, 0x65, 0xfe, 0x77, 0xe7, 0xc0, 0xc5, 0xd4, 0x5f, 0x8a, 0x0f, 0xf4, 0x02, 0xd4, - 0x7a, 0x4e, 0xc7, 0xe8, 0x51, 0xaf, 0xe5, 0xe1, 0x3d, 0xee, 0xd5, 0x67, 0x42, 0xa0, 0x86, 0xf7, - 0xd4, 0x3b, 0x50, 0x8d, 0x31, 0x40, 0x08, 0x66, 0x35, 0x56, 0xd5, 0x3a, 0xde, 0x33, 0x06, 0xbd, - 0xa0, 0x3e, 0x81, 0x66, 0x01, 0x76, 0xed, 0x0e, 0x99, 0x45, 0x6d, 0x6c, 0xd6, 0x15, 0x54, 0x83, - 0xca, 0x03, 0xc1, 0xa2, 0x5e, 0x50, 0xbf, 0x57, 0x84, 0xe3, 0xd4, 0xf0, 0xda, 0x8e, 0xc9, 0x47, - 0x02, 0x9f, 0x72, 0x5f, 0x80, 0x5a, 0x87, 0xf6, 0xa5, 0xee, 0x1a, 0x1e, 0xb6, 0x03, 0x3e, 0xf1, - 0xcc, 0x30, 0x60, 0x9b, 0xc2, 0x90, 0x06, 0x75, 0x9f, 0xb7, 0x48, 0xef, 0xb0, 0x91, 0xc3, 0x8d, - 0x5b, 0x6a, 0xf5, 0x90, 0x81, 0xa6, 0xcd, 0xf9, 0xa9, 0x91, 0x37, 0xed, 0x1f, 0xf8, 0x9d, 0xa0, - 0x27, 0xbc, 0xdd, 0xe5, 0x14, 0xab, 0xa4, 0xb0, 0x97, 0xb7, 0x19, 0xc1, 0x86, 0x1d, 0x78, 0x07, - 0x9a, 0x20, 0x47, 0xef, 0x42, 0xd9, 0x79, 0x8a, 0xbd, 0x7d, 0x6c, 0x30, 0x2f, 0x53, 0xbd, 0xf6, - 0x42, 0x8a, 0xd5, 0x9a, 0x70, 0xf4, 0x1a, 0xf6, 0x9d, 0x81, 0xd7, 0xc1, 0xbe, 0x16, 0x12, 0xa1, - 0x26, 0x54, 0x3c, 0x01, 0xe6, 0x5e, 0x68, 0x2c, 0x0e, 0x11, 0x55, 0xe3, 0x16, 0xcc, 0xc4, 0x85, - 0x43, 0x75, 0x28, 0x3e, 0xc1, 0x07, 0x5c, 0x99, 0xe4, 0x67, 0xe4, 0x9f, 0x58, 0x0f, 0xb3, 0x8f, - 0x5b, 0x85, 0x1b, 0x8a, 0xea, 0x01, 0x8a, 0x5a, 0xfa, 0x10, 0x07, 0x86, 0x69, 0x04, 0x06, 0x42, - 0x50, 0xa2, 0xc1, 0x18, 0x63, 0x41, 0x7f, 0x13, 0xae, 0x03, 0xee, 0xaa, 0x2b, 0x1a, 0xf9, 0x89, - 0x4e, 0x42, 0x25, 0xf4, 0x44, 0x3c, 0x22, 0x8b, 0x00, 0x24, 0x32, 0x32, 0x82, 0x00, 0xf7, 0xdd, - 0x80, 0x2a, 0xa6, 0xa6, 0x89, 0x4f, 0xf5, 0xd7, 0x26, 0xa1, 0x9e, 0xb2, 0x85, 0x5b, 0x50, 0xee, - 0xf3, 0xea, 0xb9, 0x0f, 0x5c, 0x95, 0xc2, 0xa3, 0x94, 0x90, 0x5a, 0x88, 0x4f, 0xa2, 0x0f, 0x62, - 0x6b, 0xb1, 0xf8, 0x31, 0xfc, 0x66, 0x46, 0xde, 0xd5, 0x4d, 0xcb, 0xc3, 0x9d, 0xc0, 0xf1, 0x0e, - 0xb8, 0xa0, 0x33, 0x3d, 0xa7, 0xbb, 0x2e, 0x60, 0xe8, 0x3a, 0x80, 0x69, 0xfb, 0x3a, 0xb5, 0xe1, - 0x2e, 0xef, 0x47, 0x69, 0x02, 0x0c, 0xc3, 0x44, 0xad, 0x62, 0xda, 0x3e, 0x17, 0xf9, 0x36, 0xd4, - 0x48, 0xcc, 0xa5, 0xf7, 0x45, 0xe0, 0x30, 0x49, 0x6d, 0x69, 0x49, 0x96, 0x3b, 0x8c, 0x00, 0xb5, - 0x19, 0x37, 0xfa, 0xf0, 0xd1, 0x1d, 0x98, 0xa2, 0x61, 0x8f, 0x08, 0x54, 0xce, 0x65, 0x37, 0x97, - 0x5b, 0xdf, 0x03, 0x8a, 0xca, 0x8c, 0x8f, 0xd3, 0xa1, 0x2d, 0xa8, 0x1a, 0xb6, 0xed, 0x04, 0x06, - 0xf3, 0xf8, 0x2c, 0x6c, 0xb9, 0x34, 0x94, 0x4d, 0x33, 0xc2, 0x67, 0xbc, 0xe2, 0x1c, 0xd0, 0x5b, - 0x30, 0x49, 0xa7, 0x04, 0xee, 0xc3, 0xcf, 0x8e, 0x1c, 0x14, 0x1a, 0xc3, 0x47, 0x6f, 0xc3, 0xf4, - 0x33, 0xcb, 0x36, 0x9d, 0x67, 0x3e, 0xf7, 0xa7, 0x92, 0x09, 0x7f, 0x99, 0x15, 0xa5, 0x88, 0x05, - 0x4d, 0xe3, 0x26, 0x54, 0x63, 0xed, 0x3b, 0x8c, 0xfd, 0x36, 0xde, 0x81, 0x7a, 0xb2, 0x4d, 0x87, - 0xb2, 0xff, 0x01, 0x2c, 0x68, 0x03, 0x3b, 0x12, 0x4d, 0x2c, 0x6f, 0xae, 0xc3, 0x14, 0xb7, 0x06, - 0x66, 0x8c, 0x27, 0x87, 0xa9, 0x55, 0xe3, 0xb8, 0xf1, 0x95, 0xca, 0xbe, 0x61, 0x9b, 0x3d, 0xec, - 0xf1, 0x1a, 0xc5, 0x4a, 0xe5, 0x3e, 0x83, 0xaa, 0x6f, 0xc3, 0xf1, 0x44, 0xb5, 0x7c, 0xa1, 0xf4, - 0x22, 0xcc, 0xba, 0x8e, 0xa9, 0xfb, 0x0c, 0x2c, 0x62, 0xc9, 0x0a, 0xb1, 0x1d, 0x81, 0xdb, 0x32, - 0x09, 0xf9, 0x76, 0xe0, 0xb8, 0x69, 0xb1, 0xc7, 0x23, 0x5f, 0x86, 0xc5, 0x24, 0x39, 0xab, 0x5e, - 0x7d, 0x17, 0x96, 0x34, 0xdc, 0x77, 0x9e, 0xe2, 0xa3, 0xb2, 0x6e, 0xc0, 0x72, 0x9a, 0x01, 0x67, - 0xfe, 0x01, 0x2c, 0x45, 0xd0, 0xed, 0xc0, 0x08, 0x06, 0xfe, 0xa1, 0x98, 0xf3, 0x55, 0xe4, 0x63, - 0xc7, 0x67, 0x1d, 0x59, 0xd6, 0xc4, 0xa7, 0xba, 0x04, 0x93, 0x6d, 0xc7, 0x6c, 0xb5, 0xd1, 0x2c, - 0x14, 0x2c, 0x97, 0x13, 0x17, 0x2c, 0x57, 0xed, 0xc4, 0xeb, 0xdc, 0x64, 0x51, 0x27, 0xab, 0x3a, - 0x89, 0x8a, 0x6e, 0xc0, 0xac, 0x61, 0x9a, 0x16, 0x31, 0x24, 0xa3, 0xa7, 0x5b, 0xae, 0x08, 0x9a, - 0xe7, 0x13, 0x5d, 0xdf, 0x6a, 0x6b, 0xb5, 0x08, 0xb1, 0xe5, 0xfa, 0xea, 0x5d, 0xa8, 0x44, 0x01, - 0xfa, 0x1b, 0xd1, 0x8a, 0xb0, 0x30, 0x3a, 0x96, 0x0b, 0x97, 0x8b, 0x9b, 0xa9, 0x49, 0x92, 0x8b, - 0xf9, 0x06, 0x40, 0xe8, 0x54, 0x45, 0x78, 0x78, 0x3c, 0x93, 0xa5, 0x16, 0x43, 0x54, 0xff, 0xad, - 0x14, 0x77, 0xb2, 0xb1, 0x26, 0x9b, 0x61, 0x93, 0x4d, 0xc9, 0xe9, 0x16, 0x0e, 0xe9, 0x74, 0x5f, - 0x83, 0x49, 0x3f, 0x30, 0x02, 0xcc, 0xe3, 0xf1, 0x95, 0x6c, 0x42, 0x52, 0x31, 0xd6, 0x18, 0x26, - 0x3a, 0x05, 0xd0, 0xf1, 0xb0, 0x11, 0x60, 0x53, 0x37, 0xd8, 0xac, 0x50, 0xd4, 0x2a, 0x1c, 0xd2, - 0x0c, 0x88, 0x17, 0x11, 0x2b, 0x88, 0x8c, 0x89, 0x30, 0xa7, 0x1b, 0xa3, 0xb5, 0x44, 0xe8, 0xbd, - 0xa6, 0x46, 0x7a, 0x2f, 0x4e, 0xca, 0xbd, 0x57, 0xe4, 0x89, 0xa7, 0x87, 0x79, 0x62, 0x46, 0x34, - 0x8e, 0x27, 0x2e, 0x0f, 0xf3, 0xc4, 0x9c, 0xcd, 0x70, 0x4f, 0x9c, 0xe1, 0x48, 0x2a, 0x59, 0x8e, - 0xe4, 0xb3, 0x74, 0x9d, 0x7f, 0x51, 0x80, 0xe5, 0xf4, 0x78, 0xe6, 0x7e, 0xec, 0x3a, 0x4c, 0xf9, - 0x14, 0x32, 0xdc, 0x7f, 0x72, 0x2a, 0x8e, 0x8b, 0xee, 0x42, 0xc9, 0xb2, 0xf7, 0x1c, 0x3e, 0xf0, - 0x2e, 0x0f, 0xa5, 0xe1, 0x35, 0x5d, 0x6e, 0xd9, 0x7b, 0x0e, 0xd3, 0x20, 0xa5, 0x45, 0x0f, 0xe0, - 0x58, 0xb8, 0xb2, 0xf6, 0x75, 0xc6, 0x18, 0x8b, 0x38, 0x4f, 0xb2, 0xd2, 0x30, 0xaa, 0xe2, 0x1c, - 0x51, 0x44, 0xb7, 0xcd, 0xc9, 0x48, 0x8c, 0x43, 0xd0, 0xfd, 0xc0, 0xe8, 0xbb, 0xc2, 0x62, 0x43, - 0x40, 0xe3, 0x2d, 0xa8, 0x84, 0xd5, 0x1f, 0x4a, 0x77, 0x2d, 0x58, 0x48, 0x8c, 0x11, 0xb6, 0x90, - 0x0c, 0x07, 0x95, 0x32, 0xee, 0xa0, 0x52, 0x7f, 0xa6, 0xc4, 0x07, 0xfa, 0x7b, 0x56, 0x2f, 0xc0, - 0x5e, 0x6a, 0xa0, 0xbf, 0x29, 0xf8, 0xb2, 0x51, 0x7e, 0x66, 0x08, 0x5f, 0xb6, 0x4e, 0xe3, 0x23, - 0xf6, 0x11, 0xcc, 0x52, 0x13, 0xd7, 0x7d, 0xdc, 0xa3, 0xb1, 0x12, 0xd7, 0xe3, 0x95, 0x6c, 0x06, - 0xac, 0x76, 0x36, 0x44, 0xb6, 0x39, 0x05, 0xeb, 0x9b, 0x5a, 0x2f, 0x0e, 0x6b, 0xdc, 0x01, 0x94, - 0x46, 0x3a, 0x94, 0x06, 0x1f, 0x12, 0x7f, 0xe9, 0x07, 0x99, 0x33, 0xf7, 0x1e, 0x15, 0x63, 0xb8, - 0xe5, 0x31, 0x51, 0x35, 0x8e, 0xab, 0xfe, 0x4b, 0x11, 0x20, 0x2a, 0xfc, 0x9c, 0x3b, 0xca, 0x5b, - 0xa1, 0xc3, 0x62, 0x11, 0xa7, 0x9a, 0xcd, 0x32, 0xd3, 0x55, 0xb5, 0x64, 0x57, 0xc5, 0x62, 0xcf, - 0x57, 0x72, 0x18, 0x1c, 0xda, 0x49, 0x4d, 0x7f, 0xde, 0x9c, 0xd4, 0x7b, 0xb0, 0x98, 0x34, 0x13, - 0xee, 0xa1, 0x5e, 0x85, 0x49, 0x2b, 0xc0, 0x7d, 0xb6, 0xdb, 0x9b, 0xd8, 0xb0, 0x88, 0xa1, 0x33, - 0x24, 0xf5, 0x1d, 0x58, 0x94, 0xfb, 0xea, 0x70, 0xa1, 0x8b, 0xfa, 0x20, 0x19, 0xfb, 0x44, 0xae, - 0x92, 0xdb, 0x47, 0xe6, 0xd6, 0x4f, 0x92, 0x86, 0x61, 0xaa, 0x3f, 0x54, 0xe0, 0x78, 0xa2, 0x28, - 0x67, 0xe0, 0x7f, 0x2d, 0x35, 0x80, 0x99, 0x6f, 0xbd, 0x3e, 0xa4, 0x96, 0x4f, 0x71, 0x14, 0x7f, - 0x19, 0x1a, 0x72, 0xf7, 0x48, 0xaa, 0xbd, 0x99, 0x18, 0xca, 0x67, 0x47, 0x0a, 0x1d, 0x8e, 0xe7, - 0x36, 0xac, 0x64, 0x32, 0x4e, 0xeb, 0xbc, 0x38, 0xa6, 0xce, 0xff, 0xb7, 0x10, 0xf7, 0xd9, 0xcd, - 0x20, 0xf0, 0xac, 0xc7, 0x83, 0x00, 0x7f, 0xb2, 0x41, 0xd5, 0x7a, 0x38, 0xb2, 0x99, 0x9f, 0x7d, - 0x35, 0x9b, 0x32, 0xaa, 0x3d, 0x73, 0x8c, 0x6f, 0xcb, 0x63, 0xbc, 0x44, 0x59, 0xbd, 0x36, 0x92, - 0xd5, 0xd0, 0xd1, 0xfe, 0x59, 0x0e, 0xe2, 0xbf, 0x57, 0x60, 0x2e, 0xd1, 0x2b, 0xe8, 0x0e, 0x80, - 0x11, 0x8a, 0xce, 0xed, 0xe3, 0xcc, 0xa8, 0x26, 0x6a, 0x31, 0x1a, 0x32, 0x27, 0xb2, 0x78, 0x31, - 0x63, 0x4e, 0xcc, 0x88, 0x17, 0xc3, 0x70, 0xf1, 0x76, 0xb4, 0xd8, 0x65, 0x9b, 0xa4, 0xea, 0xd0, - 0xc5, 0x2e, 0xa3, 0x15, 0x24, 0xea, 0xaf, 0x17, 0x60, 0x21, 0x8b, 0x3b, 0x7a, 0x19, 0x8a, 0x1d, - 0x77, 0xc0, 0x5b, 0x22, 0x1d, 0x0d, 0xad, 0xb9, 0x83, 0x5d, 0xdf, 0xe8, 0x62, 0x8d, 0x20, 0xa0, - 0x2b, 0x30, 0xd5, 0xc7, 0x7d, 0xc7, 0x3b, 0xe0, 0x72, 0x4b, 0xdb, 0x0d, 0x0f, 0x69, 0x09, 0xc3, - 0xe6, 0x68, 0xe8, 0x5a, 0x14, 0x56, 0x33, 0x79, 0x97, 0xa5, 0xd5, 0x03, 0x2b, 0x62, 0x24, 0x61, - 0x2c, 0x7d, 0x0d, 0xa6, 0x5d, 0xcf, 0xe9, 0x60, 0xdf, 0xe7, 0xbb, 0x21, 0xcb, 0x89, 0xb3, 0x2a, - 0x52, 0xc4, 0x69, 0x38, 0x22, 0xba, 0x05, 0x10, 0x05, 0x50, 0x7c, 0x66, 0x6a, 0xe4, 0xc6, 0x5b, - 0xbe, 0x16, 0xc3, 0x56, 0xbf, 0x5f, 0x80, 0xc5, 0x6c, 0xcd, 0xa1, 0x4b, 0x71, 0xbd, 0xac, 0x64, - 0xa8, 0x5a, 0x56, 0xcf, 0x9b, 0x09, 0xf5, 0xac, 0x66, 0x50, 0x64, 0x69, 0xe9, 0x66, 0x52, 0x4b, - 0xa7, 0x33, 0x08, 0xb3, 0x95, 0x75, 0x33, 0xa9, 0xac, 0x2c, 0xd2, 0x6c, 0x9d, 0x35, 0x33, 0x74, - 0x76, 0x36, 0xab, 0x8d, 0xf9, 0xaa, 0xfb, 0x1b, 0x05, 0x66, 0xe2, 0x72, 0xc9, 0x21, 0xab, 0x92, - 0x08, 0x59, 0xd1, 0x26, 0xcc, 0x9b, 0x6c, 0xe7, 0x56, 0xb7, 0xec, 0x00, 0x7b, 0x7b, 0x46, 0x47, - 0x44, 0x85, 0x67, 0x33, 0xec, 0xa2, 0x25, 0x70, 0x98, 0xe0, 0x75, 0x4e, 0x1b, 0x82, 0x49, 0x0b, - 0x42, 0x3e, 0xc2, 0x6b, 0x8d, 0xc1, 0x28, 0x46, 0xa4, 0xfe, 0xb3, 0x02, 0xc7, 0x32, 0x14, 0x3c, - 0xa2, 0x21, 0xbb, 0xf9, 0x0d, 0x39, 0x97, 0xdf, 0x75, 0x23, 0xdb, 0x73, 0x3f, 0xa3, 0x3d, 0xe3, - 0xf3, 0x8b, 0x37, 0xeb, 0xe7, 0x0a, 0x1c, 0xcf, 0xc4, 0xca, 0xdc, 0x5e, 0xbd, 0x06, 0x65, 0xef, - 0xb9, 0xfe, 0xf8, 0x20, 0xc0, 0x7e, 0xd6, 0xc0, 0xde, 0x8d, 0x9d, 0xa1, 0x4c, 0x7b, 0xcf, 0xef, - 0x12, 0x3c, 0x74, 0x1d, 0x2a, 0xde, 0x73, 0x1d, 0x7b, 0x9e, 0xe3, 0x09, 0x5f, 0x94, 0x4b, 0x54, - 0xf6, 0x9e, 0x6f, 0x50, 0x44, 0x52, 0x53, 0x20, 0x6a, 0x2a, 0x8d, 0xa8, 0x29, 0x88, 0x6a, 0x0a, - 0xc2, 0x9a, 0x26, 0x47, 0xd4, 0x14, 0xf0, 0x9a, 0xd4, 0x3f, 0x2c, 0xc0, 0xc9, 0x61, 0xea, 0xfa, - 0xc4, 0x14, 0xb1, 0x01, 0xc8, 0x7b, 0xae, 0xbb, 0x46, 0xe7, 0x09, 0x0e, 0x7c, 0xdd, 0xf4, 0x1c, - 0xd7, 0xc5, 0xe6, 0x28, 0x8d, 0xd4, 0xbd, 0xe7, 0x6d, 0x46, 0xb1, 0xce, 0x08, 0x8e, 0xa4, 0x99, - 0x0d, 0x40, 0x41, 0xba, 0xea, 0x11, 0x2a, 0xaa, 0x07, 0x89, 0xaa, 0xd5, 0x0f, 0x61, 0x26, 0xee, - 0x21, 0x46, 0xd8, 0xfe, 0x6d, 0xa8, 0x71, 0x0f, 0xa2, 0x77, 0x9c, 0x81, 0x1d, 0x8c, 0x52, 0xd4, - 0x0c, 0xc7, 0x5e, 0x23, 0xc8, 0xea, 0x37, 0xc2, 0xe1, 0xf6, 0xa9, 0x55, 0xf9, 0x47, 0x0a, 0x54, - 0x5a, 0x7d, 0xa3, 0x8b, 0xb7, 0x5d, 0xdc, 0x21, 0x33, 0xbd, 0x45, 0x3e, 0x78, 0xbf, 0xb3, 0x0f, - 0x74, 0x5f, 0x8e, 0x5a, 0x58, 0x9c, 0xfa, 0xb2, 0x74, 0x8e, 0x28, 0x38, 0x8c, 0x08, 0x55, 0x3e, - 0x6e, 0xbc, 0x71, 0x0d, 0xca, 0x5f, 0xc4, 0x07, 0x6c, 0x45, 0x3e, 0x26, 0x9d, 0xfa, 0x9d, 0x12, - 0x2c, 0xe5, 0x9c, 0xd5, 0xd0, 0xe5, 0x9c, 0x3b, 0xd0, 0x5d, 0xec, 0x59, 0x8e, 0x29, 0x54, 0xdb, - 0x71, 0x07, 0x6d, 0x0a, 0x40, 0x2b, 0x40, 0x3e, 0xf4, 0x6f, 0x0c, 0x1c, 0x1e, 0x31, 0x16, 0xb5, - 0x72, 0xc7, 0x1d, 0x7c, 0x89, 0x7c, 0x0b, 0x5a, 0x7f, 0xdf, 0xf0, 0x30, 0x1b, 0xe4, 0x8c, 0x76, - 0x9b, 0x02, 0xd0, 0x6b, 0x70, 0x9c, 0x4d, 0x60, 0x7a, 0xcf, 0xea, 0x5b, 0xc4, 0x15, 0xc6, 0xec, - 0xb7, 0xa8, 0x21, 0x56, 0xf8, 0x80, 0x94, 0xb5, 0x6c, 0x66, 0xb1, 0x2a, 0xd4, 0x1c, 0xa7, 0xaf, - 0xfb, 0x1d, 0xc7, 0xc3, 0xba, 0x61, 0x7e, 0x48, 0x8d, 0xb5, 0xa8, 0x55, 0x1d, 0xa7, 0xbf, 0x4d, - 0x60, 0x4d, 0xf3, 0x43, 0x74, 0x1a, 0xaa, 0x1d, 0x77, 0xe0, 0xe3, 0x40, 0x27, 0x7f, 0xe8, 0x8e, - 0x5a, 0x45, 0x03, 0x06, 0x5a, 0x73, 0x07, 0x7e, 0x0c, 0xa1, 0x4f, 0xd6, 0x50, 0xd3, 0x71, 0x84, - 0x87, 0xb8, 0x4f, 0x8f, 0xa4, 0xf7, 0x07, 0x5d, 0xec, 0x1a, 0x5d, 0xcc, 0x44, 0x13, 0xdb, 0x62, - 0xd2, 0x91, 0xf4, 0x7d, 0x8e, 0x42, 0x05, 0xd4, 0x66, 0xf7, 0xe3, 0x9f, 0x3e, 0x7a, 0x1f, 0xa6, - 0x07, 0xb6, 0xb5, 0x67, 0x61, 0x73, 0xb9, 0x42, 0x69, 0xaf, 0x8e, 0x71, 0x32, 0x76, 0x79, 0x97, - 0x91, 0xf0, 0x83, 0x3a, 0xce, 0x00, 0xdd, 0x82, 0x06, 0x57, 0x94, 0xff, 0xcc, 0x70, 0x93, 0xda, - 0x02, 0xaa, 0x82, 0x45, 0x86, 0xb1, 0xfd, 0xcc, 0x70, 0xe3, 0x1a, 0x6b, 0xdc, 0x82, 0x99, 0x38, - 0xd3, 0x43, 0xd9, 0xd2, 0x5d, 0xa8, 0x49, 0x8d, 0x24, 0xbd, 0x4d, 0x95, 0xe2, 0x5b, 0xdf, 0x14, - 0x03, 0xa0, 0x4c, 0x00, 0xdb, 0xd6, 0x37, 0x69, 0x22, 0x01, 0x95, 0x8c, 0xf2, 0x29, 0x69, 0xec, - 0x43, 0x35, 0xa0, 0x26, 0x9d, 0xdd, 0x13, 0xbf, 0x49, 0x0f, 0xe9, 0xb9, 0xdf, 0x24, 0xbf, 0x09, - 0xcc, 0x73, 0x7a, 0x42, 0x02, 0xfa, 0x9b, 0xc0, 0xe8, 0x29, 0x31, 0x3b, 0xf3, 0xa2, 0xbf, 0x69, - 0x15, 0xf8, 0x29, 0x4f, 0xc2, 0xa9, 0x68, 0xec, 0x43, 0xfd, 0x6d, 0x05, 0x60, 0xcd, 0x70, 0x8d, - 0xc7, 0x56, 0xcf, 0x0a, 0x0e, 0xd0, 0x79, 0xa8, 0x1b, 0xa6, 0xa9, 0x77, 0x04, 0xc4, 0xc2, 0x22, - 0x2b, 0x6a, 0xce, 0x30, 0xcd, 0xb5, 0x18, 0x18, 0x5d, 0x84, 0x79, 0xe2, 0xf5, 0x64, 0x5c, 0x96, - 0x26, 0x55, 0x27, 0x05, 0x12, 0xf2, 0x0d, 0x58, 0x26, 0x7c, 0x8d, 0xfe, 0x63, 0x0b, 0xdb, 0x81, - 0x4c, 0xc3, 0xf2, 0xa7, 0x16, 0x0d, 0xd3, 0x6c, 0xb2, 0xe2, 0x38, 0xa5, 0xfa, 0xd7, 0x53, 0x70, - 0x4a, 0xee, 0xf1, 0x64, 0x3a, 0xc5, 0x2d, 0x98, 0x49, 0xc8, 0x9b, 0x4a, 0x44, 0x88, 0x5a, 0xa8, - 0x49, 0xb8, 0x89, 0x84, 0x81, 0x42, 0x2a, 0x61, 0x20, 0x33, 0x55, 0xa3, 0xf8, 0x09, 0xa5, 0x6a, - 0x94, 0x3e, 0x66, 0xaa, 0xc6, 0xe4, 0x51, 0x53, 0x35, 0x66, 0xc6, 0x4e, 0xd5, 0x78, 0x99, 0x6e, - 0xf5, 0x88, 0x1a, 0xe9, 0x9c, 0xcd, 0x7c, 0x42, 0x2d, 0xe4, 0x6e, 0x8b, 0x54, 0xbd, 0x44, 0x4a, - 0xc7, 0xf4, 0x61, 0x52, 0x3a, 0xca, 0xb9, 0x29, 0x1d, 0x67, 0x60, 0xc6, 0x76, 0x74, 0x1b, 0x3f, - 0xd3, 0x49, 0xb7, 0xf8, 0xcb, 0x55, 0xd6, 0x47, 0xb6, 0xb3, 0x89, 0x9f, 0xb5, 0x09, 0x04, 0x9d, - 0x85, 0x99, 0xbe, 0xe1, 0x3f, 0xc1, 0x26, 0xcd, 0xad, 0xf0, 0x97, 0x6b, 0xd4, 0x9e, 0xaa, 0x0c, - 0xd6, 0x26, 0x20, 0xf4, 0x12, 0x84, 0x72, 0x70, 0xa4, 0x59, 0x8a, 0x54, 0x13, 0x50, 0x86, 0x16, - 0x4b, 0x0f, 0x99, 0x3b, 0x62, 0x7a, 0x48, 0xfd, 0x30, 0xe9, 0x21, 0x97, 0xa0, 0x2e, 0x7e, 0x8b, - 0xfc, 0x10, 0xb6, 0xdd, 0x4f, 0x53, 0x43, 0xe6, 0x44, 0x99, 0xc8, 0x01, 0xc9, 0xcb, 0x26, 0x81, - 0xa1, 0xd9, 0x24, 0x7f, 0xac, 0xf0, 0x85, 0x67, 0x38, 0x80, 0xf8, 0x31, 0xb6, 0x94, 0x81, 0xa0, - 0x1c, 0x25, 0x03, 0x01, 0xed, 0xe4, 0xe6, 0x68, 0x9c, 0xcf, 0xe7, 0x34, 0x2a, 0x4b, 0x43, 0x7d, - 0x18, 0xae, 0x09, 0x3f, 0x89, 0x5c, 0x33, 0xf5, 0x3f, 0x14, 0x38, 0xc5, 0xf9, 0xe5, 0x24, 0x64, - 0x65, 0x58, 0xb9, 0x92, 0x63, 0xe5, 0x1d, 0x0f, 0x9b, 0xd8, 0x0e, 0x2c, 0xa3, 0xa7, 0xfb, 0x2e, - 0xee, 0x88, 0x63, 0xde, 0x08, 0x4c, 0x03, 0x9d, 0xb3, 0x30, 0xc3, 0x72, 0x26, 0xf9, 0xf2, 0x90, - 0xa5, 0x46, 0x56, 0x69, 0xda, 0x24, 0x5f, 0x01, 0x6e, 0x65, 0x79, 0x96, 0x52, 0xee, 0xbe, 0xc2, - 0x48, 0x07, 0xa3, 0x3a, 0xb0, 0x94, 0x73, 0xe0, 0x9e, 0xd9, 0x4d, 0x4a, 0xba, 0x9b, 0x86, 0x2a, - 0x29, 0xdd, 0x4d, 0xdf, 0x51, 0xe0, 0x74, 0x6a, 0x99, 0xfa, 0xd9, 0x6b, 0x56, 0xfd, 0x33, 0x25, - 0xb4, 0x9f, 0xa4, 0xc9, 0xaf, 0xa5, 0x4d, 0xfe, 0xa5, 0x61, 0xab, 0xee, 0x4c, 0xa3, 0x7f, 0x94, - 0x6b, 0xf4, 0x17, 0x87, 0xae, 0xe0, 0x47, 0xe9, 0xf3, 0x5f, 0x15, 0x38, 0x91, 0x2b, 0x40, 0x22, - 0x1e, 0x54, 0x92, 0xf1, 0x20, 0x8f, 0x25, 0xa3, 0x10, 0x9d, 0xc5, 0x92, 0x34, 0x0a, 0xe7, 0x41, - 0x9b, 0xde, 0x37, 0x9e, 0x5b, 0xfd, 0x41, 0x9f, 0x07, 0x93, 0x84, 0xdd, 0x43, 0x06, 0x39, 0x4a, - 0x34, 0x79, 0x05, 0x16, 0x98, 0xa3, 0xa7, 0x01, 0x4d, 0x44, 0xc1, 0x82, 0xca, 0x79, 0x56, 0x46, - 0x62, 0x1b, 0x4e, 0xa0, 0x36, 0x61, 0x3e, 0x6c, 0xd6, 0xd0, 0x84, 0xa3, 0x58, 0x02, 0x51, 0x41, - 0x4e, 0x20, 0xb2, 0x61, 0x6a, 0x1d, 0x3f, 0xb5, 0x3a, 0xf8, 0x13, 0xc9, 0x5d, 0x3e, 0x03, 0x55, - 0x17, 0x7b, 0x7d, 0xcb, 0xf7, 0xc3, 0x59, 0xbd, 0xa2, 0xc5, 0x41, 0xea, 0x69, 0xa8, 0xac, 0xad, - 0xb7, 0x78, 0x95, 0x19, 0xa2, 0xaa, 0xff, 0x39, 0x05, 0x73, 0x49, 0x1b, 0xbb, 0x99, 0x4a, 0x68, - 0x3a, 0x95, 0xb9, 0x19, 0x96, 0xb1, 0x0b, 0x7c, 0x51, 0xac, 0x8f, 0x0a, 0xe9, 0xd3, 0xfe, 0x70, - 0x0d, 0x24, 0x96, 0x4d, 0xcb, 0x30, 0xdd, 0x71, 0xfa, 0x7d, 0xc3, 0x36, 0x45, 0x06, 0x3a, 0xff, - 0x24, 0x92, 0x1a, 0x5e, 0x97, 0xed, 0xff, 0x56, 0x34, 0xfa, 0x9b, 0x98, 0x00, 0x71, 0x86, 0x96, - 0x4d, 0x53, 0xa2, 0x68, 0x2f, 0x55, 0x34, 0xe0, 0xa0, 0x75, 0xcb, 0x43, 0xe7, 0xa0, 0x84, 0xed, - 0xa7, 0xe2, 0x60, 0x48, 0xda, 0x87, 0x14, 0x6b, 0x22, 0x8d, 0x62, 0xa0, 0xf3, 0x30, 0xd5, 0x27, - 0x66, 0x25, 0x8e, 0xcd, 0xe7, 0x53, 0x99, 0xda, 0x1a, 0x47, 0x40, 0xaf, 0xc2, 0xb4, 0x49, 0xb5, - 0x27, 0x16, 0x01, 0x48, 0x4a, 0xae, 0xa2, 0x45, 0x9a, 0x40, 0x41, 0xef, 0x86, 0x9b, 0xe0, 0x95, - 0xf4, 0xe9, 0x54, 0x42, 0xcd, 0x99, 0xfb, 0xdf, 0x9b, 0xf2, 0x4a, 0x12, 0xd2, 0x5b, 0xe9, 0x49, - 0x2e, 0xc3, 0x0f, 0xba, 0x4e, 0x40, 0xb9, 0xe7, 0x74, 0x99, 0xf5, 0x54, 0xd9, 0xf5, 0x85, 0x9e, - 0xd3, 0xa5, 0xc6, 0xb3, 0x00, 0x93, 0x7e, 0x60, 0x5a, 0x36, 0x8d, 0xa5, 0xca, 0x1a, 0xfb, 0x20, - 0x83, 0x94, 0xfe, 0xd0, 0x1d, 0xbb, 0x83, 0x97, 0x6b, 0xb4, 0xa8, 0x42, 0x21, 0x5b, 0x76, 0x87, - 0xae, 0x29, 0x83, 0xe0, 0x60, 0x79, 0x96, 0xc2, 0xc9, 0xcf, 0x68, 0x2f, 0x7a, 0x2e, 0x67, 0x2f, - 0x3a, 0x21, 0x70, 0xc6, 0x5e, 0x74, 0x3d, 0x77, 0xce, 0x48, 0xd2, 0x0a, 0x12, 0x12, 0x47, 0xae, - 0xad, 0xb7, 0x74, 0xd1, 0x35, 0xf3, 0xe9, 0xc4, 0xef, 0xd0, 0xec, 0x35, 0x08, 0x7f, 0x7e, 0xa6, - 0x47, 0x01, 0xdf, 0x57, 0x60, 0x71, 0x8d, 0x1e, 0x84, 0xc6, 0x7c, 0xe3, 0x61, 0x72, 0x88, 0x5e, - 0x0f, 0x13, 0xbb, 0x32, 0xb2, 0x73, 0x92, 0x9a, 0x12, 0x79, 0x5d, 0x6b, 0x30, 0x2b, 0xd8, 0x72, - 0xe2, 0xe2, 0x18, 0x59, 0x61, 0x35, 0x3f, 0xfe, 0xa9, 0xde, 0x86, 0xa5, 0x94, 0xe4, 0xfc, 0x38, - 0x2a, 0x79, 0x43, 0x80, 0x09, 0x1e, 0xbf, 0x21, 0xa0, 0xde, 0x82, 0xe3, 0xdb, 0x81, 0xe1, 0x05, - 0xa9, 0x66, 0x8f, 0x41, 0x4b, 0xf3, 0xbd, 0x64, 0x5a, 0x9e, 0x92, 0xb5, 0x0d, 0x0b, 0xdb, 0x81, - 0xe3, 0x1e, 0x81, 0x29, 0xf1, 0x3b, 0xa4, 0xe5, 0xce, 0x40, 0xcc, 0x33, 0xe2, 0x53, 0x5d, 0x62, - 0xd9, 0x69, 0xe9, 0xda, 0xbe, 0x00, 0x8b, 0x2c, 0x39, 0xec, 0x28, 0x8d, 0x38, 0x21, 0x52, 0xd3, - 0xd2, 0x7c, 0xef, 0xc1, 0x31, 0x69, 0x83, 0x9c, 0x27, 0x53, 0x5c, 0x95, 0x93, 0x29, 0xf2, 0xcf, - 0x22, 0xc2, 0x5c, 0x8a, 0xef, 0x16, 0x62, 0x7e, 0x3c, 0xe7, 0x44, 0xf5, 0x0d, 0x39, 0x95, 0xe2, - 0x74, 0x3e, 0x57, 0x29, 0x93, 0x22, 0x6d, 0x9d, 0xc5, 0x0c, 0xeb, 0xdc, 0x4d, 0x1d, 0xd7, 0x96, - 0xd2, 0xa9, 0x30, 0x09, 0x09, 0x3f, 0x95, 0x83, 0xda, 0x07, 0x2c, 0xdd, 0x22, 0xac, 0x3a, 0x3c, - 0xa3, 0x7d, 0x3d, 0x71, 0x46, 0xbb, 0x32, 0x44, 0xd2, 0xf0, 0x74, 0xf6, 0xbb, 0x25, 0xa8, 0x84, - 0x65, 0x29, 0x0d, 0xa7, 0x55, 0x55, 0xc8, 0x50, 0x55, 0x7c, 0x7e, 0x2d, 0x1e, 0x71, 0x7e, 0x2d, - 0x8d, 0x31, 0xbf, 0xae, 0x40, 0x85, 0xfe, 0xa0, 0x19, 0xf2, 0x6c, 0xbe, 0x2c, 0x53, 0x80, 0x86, - 0xf7, 0x22, 0x13, 0x9b, 0x1a, 0xd3, 0xc4, 0x12, 0xa9, 0x1d, 0xd3, 0xc9, 0xd4, 0x8e, 0x9b, 0xe1, - 0xdc, 0x57, 0x4e, 0x1f, 0xa5, 0x84, 0x1c, 0x33, 0x67, 0xbd, 0xc4, 0xfe, 0x69, 0x25, 0xbd, 0x7f, - 0x1a, 0xd1, 0x7f, 0x6e, 0x8f, 0x7a, 0xb7, 0x58, 0xbe, 0x46, 0xdc, 0xce, 0xb8, 0x8f, 0x7c, 0x43, - 0x3a, 0x2a, 0x53, 0x32, 0xe6, 0xaa, 0xd0, 0x2f, 0xc4, 0x8f, 0xc7, 0x76, 0x61, 0x31, 0x99, 0xe7, - 0x75, 0x28, 0x1f, 0x97, 0x93, 0x70, 0xfa, 0x9b, 0xf1, 0x88, 0x2f, 0x27, 0xbb, 0xf2, 0x66, 0x2a, - 0x11, 0x60, 0x6c, 0x0b, 0xbd, 0x2a, 0xe7, 0x0c, 0x1d, 0xda, 0xae, 0x52, 0x29, 0x43, 0x34, 0x22, - 0x31, 0x3c, 0x5e, 0xcc, 0x82, 0xf3, 0x0a, 0x87, 0x34, 0xe9, 0xca, 0x60, 0xcf, 0xb2, 0x2d, 0x7f, - 0x9f, 0x95, 0x4f, 0xb1, 0x95, 0x81, 0x00, 0x35, 0xe9, 0xae, 0x25, 0x7e, 0x6e, 0x05, 0x7a, 0xc7, - 0x31, 0x31, 0xb5, 0xda, 0x49, 0xad, 0x4c, 0x00, 0x6b, 0x8e, 0x89, 0xa3, 0xf1, 0x54, 0x3e, 0xec, - 0x78, 0xaa, 0x24, 0xc6, 0xd3, 0x22, 0x4c, 0x79, 0xd8, 0xf0, 0x1d, 0x9b, 0x6d, 0x66, 0x68, 0xfc, - 0x8b, 0x74, 0x44, 0x1f, 0xfb, 0x3e, 0xa9, 0x83, 0x07, 0x60, 0xfc, 0x33, 0x16, 0x2c, 0xce, 0x0c, - 0x09, 0x16, 0x87, 0xe4, 0x6e, 0x26, 0x82, 0xc5, 0xda, 0x90, 0x60, 0x71, 0xac, 0xd4, 0xcd, 0x28, - 0x2c, 0x9e, 0x1d, 0x15, 0x16, 0xc7, 0xe3, 0xca, 0x39, 0x39, 0xae, 0xbc, 0x1d, 0x5f, 0xa1, 0xd6, - 0xd3, 0x27, 0xd9, 0xc3, 0x6f, 0x84, 0x7c, 0x86, 0x03, 0xf8, 0x1f, 0x14, 0x58, 0x4a, 0x0d, 0x38, - 0x3e, 0x84, 0x5f, 0x4f, 0x24, 0x85, 0x0e, 0xcd, 0xc6, 0x14, 0x39, 0xa1, 0x4d, 0x29, 0x27, 0xf4, - 0xd2, 0x30, 0x92, 0x9c, 0x94, 0xd0, 0xa3, 0xa7, 0x69, 0x7e, 0x5b, 0x01, 0x94, 0xb1, 0x06, 0xbf, - 0x29, 0xa2, 0xf5, 0x43, 0xec, 0x96, 0xf1, 0x80, 0xfd, 0xdd, 0x28, 0x60, 0x2f, 0x1c, 0x66, 0xdf, - 0x21, 0xcc, 0x1f, 0xf9, 0x49, 0x01, 0x4e, 0xef, 0xba, 0x66, 0x22, 0x8c, 0xe4, 0x58, 0xe3, 0x7b, - 0xb6, 0x9b, 0x72, 0xf2, 0xcb, 0x11, 0x9b, 0x50, 0x3c, 0x4a, 0x13, 0xd0, 0xd7, 0xb3, 0xd2, 0x93, - 0x6e, 0x4b, 0x07, 0x89, 0xc3, 0x1b, 0xf8, 0x0b, 0x3e, 0xfe, 0x53, 0xe1, 0x4c, 0xbe, 0x00, 0x3c, - 0xe4, 0xfc, 0xff, 0x30, 0xb7, 0xf1, 0x1c, 0x77, 0xb6, 0x0f, 0xec, 0xce, 0x21, 0xb4, 0x5e, 0x87, - 0x62, 0xa7, 0x6f, 0xf2, 0xd3, 0x11, 0xf2, 0x33, 0x1e, 0x45, 0x17, 0xe5, 0x28, 0x5a, 0x87, 0x7a, - 0x54, 0x03, 0x1f, 0x40, 0x8b, 0x64, 0x00, 0x99, 0x04, 0x99, 0x30, 0x9f, 0xd1, 0xf8, 0x17, 0x87, - 0x63, 0x8f, 0x5d, 0x37, 0x61, 0x70, 0xec, 0x79, 0xb2, 0xd7, 0x2e, 0xca, 0x5e, 0x5b, 0xfd, 0x9e, - 0x02, 0x55, 0x52, 0xc3, 0xc7, 0x92, 0x9f, 0x2f, 0x65, 0x8b, 0xd1, 0x52, 0x36, 0x5c, 0x11, 0x97, - 0xe2, 0x2b, 0xe2, 0x48, 0xf2, 0x49, 0x0a, 0x4e, 0x4b, 0x3e, 0x15, 0xc2, 0xb1, 0xe7, 0xa9, 0x67, - 0x60, 0x86, 0xc9, 0xc6, 0x5b, 0x5e, 0x87, 0xe2, 0xc0, 0xeb, 0x89, 0xfe, 0x1b, 0x78, 0x3d, 0xf5, - 0x5b, 0x0a, 0xd4, 0x9a, 0x41, 0x60, 0x74, 0xf6, 0x0f, 0xd1, 0x80, 0x50, 0xb8, 0x42, 0x5c, 0xb8, - 0x74, 0x23, 0x22, 0x71, 0x4b, 0x39, 0xe2, 0x4e, 0x4a, 0xe2, 0xaa, 0x30, 0x2b, 0x64, 0xc9, 0x15, - 0x78, 0x13, 0x50, 0xdb, 0xf1, 0x82, 0xf7, 0x1c, 0xef, 0x99, 0xe1, 0x99, 0x87, 0x5b, 0xb5, 0x22, - 0x28, 0xf1, 0x07, 0x00, 0x8a, 0xe7, 0x26, 0x35, 0xfa, 0x5b, 0x7d, 0x05, 0x8e, 0x49, 0xfc, 0x72, - 0x2b, 0xbe, 0x05, 0x55, 0x3a, 0x0b, 0xf3, 0x05, 0xcd, 0xc5, 0xf8, 0xe9, 0xfb, 0x88, 0xd9, 0x5a, - 0x5d, 0x87, 0x79, 0x12, 0x8f, 0x51, 0x78, 0xe8, 0x5f, 0xae, 0x24, 0x62, 0xfe, 0xa5, 0x14, 0x8b, - 0x44, 0xbc, 0xff, 0x33, 0x05, 0x26, 0x29, 0x3c, 0x15, 0x23, 0xad, 0x90, 0x79, 0xce, 0x75, 0xf4, - 0xc0, 0xe8, 0x86, 0x8f, 0x2b, 0x10, 0xc0, 0x8e, 0xd1, 0xa5, 0x27, 0x3a, 0xb4, 0xd0, 0xb4, 0xba, - 0xd8, 0x0f, 0xc4, 0x09, 0x61, 0x95, 0xc0, 0xd6, 0x19, 0x88, 0x28, 0x86, 0x1e, 0xa4, 0x96, 0xe8, - 0x79, 0x29, 0xfd, 0x8d, 0xce, 0xb1, 0x9b, 0x8a, 0xc3, 0x8f, 0xc5, 0xe8, 0x0d, 0xc6, 0x06, 0x94, - 0x13, 0xe7, 0x59, 0xe1, 0x37, 0x3a, 0x0f, 0x25, 0xba, 0xff, 0x3c, 0x3d, 0x4c, 0x4b, 0x14, 0x85, - 0x58, 0x85, 0x6b, 0xd9, 0x36, 0x36, 0x69, 0x00, 0x54, 0xd6, 0xf8, 0x97, 0xfa, 0x2e, 0xa0, 0xb8, - 0xf2, 0x78, 0x07, 0x9d, 0x87, 0x29, 0xaa, 0x5b, 0x11, 0xc4, 0xce, 0xa7, 0x58, 0x6b, 0x1c, 0x41, - 0xfd, 0x1a, 0x20, 0x56, 0x97, 0x14, 0xb8, 0x1e, 0xa6, 0x03, 0x87, 0x84, 0xb0, 0x7f, 0xae, 0xc0, - 0x31, 0x89, 0x3b, 0x97, 0xef, 0x15, 0x99, 0x7d, 0x86, 0x78, 0x9c, 0xf5, 0xdb, 0xd2, 0xcc, 0x7c, - 0x3e, 0x2d, 0xc6, 0x2f, 0x68, 0x56, 0xfe, 0x47, 0x05, 0xa0, 0x39, 0x08, 0xf6, 0xf9, 0x46, 0x6b, - 0xbc, 0x13, 0x95, 0x44, 0x27, 0x36, 0xa0, 0xec, 0x1a, 0xbe, 0xff, 0xcc, 0xf1, 0xc4, 0x22, 0x32, - 0xfc, 0xa6, 0xdb, 0xa3, 0x03, 0xfe, 0xe2, 0x42, 0x45, 0xa3, 0xbf, 0xd1, 0x4b, 0x30, 0xcb, 0x5e, - 0xfd, 0xd0, 0x0d, 0xd3, 0xf4, 0x44, 0x46, 0x5f, 0x45, 0xab, 0x31, 0x68, 0x93, 0x01, 0x09, 0x9a, - 0x45, 0x4f, 0x23, 0x82, 0x03, 0x3d, 0x70, 0x9e, 0x60, 0x9b, 0x2f, 0x0c, 0x6b, 0x02, 0xba, 0x43, - 0x80, 0xec, 0xb8, 0xb1, 0x6b, 0xf9, 0x81, 0x27, 0xd0, 0xc4, 0xa1, 0x29, 0x87, 0x52, 0x34, 0xf5, - 0x4f, 0x14, 0xa8, 0xb7, 0x07, 0xbd, 0x1e, 0x53, 0xee, 0x51, 0x3a, 0xf9, 0x02, 0x6f, 0x4a, 0x21, - 0x6d, 0xf2, 0x91, 0xa2, 0x78, 0x13, 0x3f, 0x91, 0xbd, 0xac, 0xab, 0x30, 0x1f, 0x93, 0x98, 0x1b, - 0x8e, 0x14, 0xd9, 0x2b, 0x72, 0x64, 0xaf, 0x36, 0x01, 0xb1, 0xed, 0x9b, 0x23, 0xb7, 0x52, 0x3d, - 0x0e, 0xc7, 0x24, 0x16, 0x7c, 0x2a, 0xbe, 0x00, 0x35, 0x9e, 0x5d, 0xc6, 0x0d, 0xe2, 0x04, 0x94, - 0x89, 0x4b, 0xed, 0x58, 0xa6, 0xc8, 0x90, 0x98, 0x76, 0x1d, 0x73, 0xcd, 0x32, 0x3d, 0xf5, 0x4b, - 0x50, 0xe3, 0xd7, 0xd7, 0x39, 0xee, 0x1d, 0x98, 0xe5, 0xe7, 0x83, 0xba, 0x74, 0xdf, 0xf3, 0x44, - 0x46, 0x0a, 0xa3, 0x50, 0x85, 0x1d, 0xff, 0x54, 0xbf, 0x0e, 0x0d, 0x16, 0x2d, 0x48, 0x8c, 0x45, - 0x03, 0xef, 0x80, 0xb8, 0x0c, 0x31, 0x84, 0xbf, 0x4c, 0x59, 0xf3, 0xe2, 0x9f, 0xea, 0x29, 0x58, - 0xc9, 0xe4, 0xcf, 0x5b, 0xef, 0x42, 0x3d, 0x2a, 0x60, 0x97, 0x12, 0xc3, 0xb4, 0x0f, 0x25, 0x96, - 0xf6, 0xb1, 0x18, 0xc6, 0xde, 0x05, 0x31, 0x73, 0xd1, 0xf0, 0x3a, 0x5a, 0x71, 0x15, 0xf3, 0x56, - 0x5c, 0x25, 0x69, 0xc5, 0xa5, 0x3e, 0x0c, 0x75, 0xc8, 0xd7, 0xbd, 0xb7, 0xe9, 0xca, 0x9c, 0xd5, - 0x2d, 0x9c, 0xda, 0xc9, 0xec, 0xf6, 0x31, 0x24, 0x2d, 0x86, 0xaf, 0x9e, 0x87, 0x9a, 0xec, 0xde, - 0x62, 0x1e, 0x4b, 0x49, 0x79, 0xac, 0xd9, 0x84, 0xb3, 0x7a, 0x2d, 0xb1, 0xa4, 0xc8, 0xd2, 0x6b, - 0x62, 0x41, 0x71, 0x43, 0x72, 0x5b, 0x2f, 0x4a, 0x47, 0xf4, 0xbf, 0x20, 0x8f, 0xb5, 0xc0, 0xfd, - 0xf8, 0x7b, 0x3e, 0xa1, 0xe7, 0x0d, 0x55, 0x5f, 0x80, 0xea, 0x6e, 0xde, 0x23, 0x22, 0x25, 0x91, - 0x57, 0xf6, 0x26, 0x2c, 0xbc, 0x67, 0xf5, 0xb0, 0x7f, 0xe0, 0x07, 0xb8, 0xdf, 0xa2, 0xee, 0x65, - 0xcf, 0xc2, 0x1e, 0x5a, 0x05, 0xa0, 0xab, 0x48, 0xd7, 0xb1, 0xc2, 0x87, 0x13, 0x62, 0x10, 0xf5, - 0xc7, 0x0a, 0xcc, 0x45, 0x84, 0xe3, 0x64, 0xf8, 0xbd, 0x01, 0x93, 0x7b, 0xbe, 0xd8, 0x6d, 0x4b, - 0x9c, 0x41, 0x64, 0x89, 0xa0, 0x95, 0xf6, 0xfc, 0x96, 0x89, 0xde, 0x04, 0x18, 0xf8, 0xd8, 0xe4, - 0xc7, 0x7e, 0x23, 0x72, 0x2e, 0x2b, 0x04, 0x95, 0x1d, 0x1c, 0xde, 0x80, 0xaa, 0x65, 0x3b, 0x26, - 0xa6, 0x47, 0xc2, 0xe6, 0xa8, 0x7c, 0x4b, 0x60, 0xb8, 0xbb, 0x3e, 0x36, 0xd5, 0xdf, 0x8b, 0x0e, - 0x76, 0x3f, 0xcf, 0x2d, 0x54, 0x75, 0x3e, 0xbf, 0x8a, 0x5e, 0xe7, 0x26, 0x7b, 0x1f, 0xe6, 0x99, - 0x9b, 0xdc, 0x0b, 0xab, 0xcc, 0xbc, 0x87, 0x92, 0x68, 0x9b, 0x56, 0xb7, 0x78, 0x64, 0x25, 0x88, - 0xd4, 0x5b, 0x70, 0x3c, 0x91, 0x18, 0x3e, 0xfe, 0x76, 0xfa, 0xfb, 0x89, 0x7d, 0xb1, 0x68, 0x48, - 0x5d, 0x95, 0xef, 0x23, 0x0d, 0x4b, 0xe1, 0xe7, 0x57, 0x63, 0x76, 0xe1, 0x84, 0xb4, 0x69, 0x27, - 0xc9, 0x72, 0x23, 0x11, 0x2c, 0x9e, 0xc9, 0xe7, 0x97, 0x88, 0x1a, 0xff, 0x4b, 0x81, 0x85, 0x2c, - 0x84, 0x23, 0x6e, 0x18, 0x7f, 0x35, 0xe7, 0x2e, 0xe3, 0xeb, 0xa3, 0x04, 0xfa, 0x54, 0x36, 0xd8, - 0x37, 0xd9, 0x4d, 0xa8, 0xd1, 0x7d, 0x52, 0x1c, 0xaf, 0x4f, 0x7e, 0x56, 0x88, 0x1d, 0x8a, 0x0c, - 0xb9, 0xad, 0xf4, 0x31, 0x36, 0x29, 0xd7, 0x12, 0x97, 0x95, 0x2e, 0x66, 0x12, 0x8e, 0xb8, 0xab, - 0xa4, 0x65, 0x6d, 0x06, 0x5c, 0x1d, 0xc5, 0xe9, 0x73, 0xbb, 0x7f, 0xfd, 0xdf, 0x0a, 0xcc, 0xca, - 0x1d, 0x82, 0xde, 0xcd, 0xb8, 0xa9, 0x74, 0x7a, 0x44, 0x03, 0xa5, 0x8b, 0x4a, 0xfc, 0x66, 0x50, - 0x61, 0xfc, 0x9b, 0x41, 0xc5, 0xf1, 0x6e, 0x06, 0xdd, 0x85, 0xd9, 0x67, 0x9e, 0x15, 0x18, 0x8f, - 0x7b, 0x58, 0xef, 0x19, 0x07, 0xd8, 0xe3, 0x5e, 0x78, 0xa8, 0x1b, 0xaa, 0x09, 0x92, 0x07, 0x84, - 0x42, 0xfd, 0x56, 0x01, 0x8e, 0x67, 0x5e, 0x52, 0xf9, 0xf8, 0xed, 0xbe, 0x14, 0x6f, 0xf7, 0x61, - 0x6e, 0xfe, 0x14, 0x0f, 0x75, 0xf3, 0xa7, 0x95, 0xa3, 0x85, 0xac, 0xa3, 0xf4, 0x11, 0xca, 0xf8, - 0x4b, 0x05, 0xca, 0x42, 0xa8, 0x91, 0xf7, 0x70, 0x96, 0x06, 0x04, 0x4d, 0xa7, 0x69, 0xd8, 0xb6, - 0x61, 0x3b, 0xba, 0x8f, 0x49, 0x58, 0x34, 0xf2, 0xd6, 0xc3, 0x02, 0xa5, 0x5b, 0x73, 0x3c, 0xbc, - 0x69, 0xd8, 0xce, 0x36, 0x23, 0x42, 0x4d, 0xa8, 0x33, 0x7e, 0x94, 0x15, 0x61, 0x3a, 0x72, 0xaa, - 0x9a, 0xa5, 0x04, 0x84, 0x09, 0x61, 0xe6, 0xab, 0x3f, 0x50, 0x60, 0x2e, 0xa1, 0xd9, 0x5f, 0xbe, - 0x46, 0xfc, 0x6e, 0x11, 0xaa, 0xb1, 0x5e, 0x1e, 0xd1, 0x80, 0x35, 0x98, 0x17, 0xe9, 0x30, 0x3e, - 0x0e, 0xc6, 0xbb, 0x75, 0x32, 0xc7, 0x29, 0xb6, 0x71, 0xc0, 0x22, 0x99, 0x3b, 0x30, 0x67, 0x3c, - 0x35, 0xac, 0x1e, 0xb5, 0xa0, 0xb1, 0x82, 0x84, 0xd9, 0x10, 0x3f, 0x8c, 0x85, 0x58, 0xbb, 0xc7, - 0xba, 0x7b, 0x02, 0x14, 0x37, 0xba, 0x02, 0xe4, 0xfb, 0xb1, 0x9c, 0xab, 0xa1, 0x57, 0x80, 0x7c, - 0x3f, 0xac, 0x8f, 0xe6, 0xa0, 0xd3, 0xbb, 0x4f, 0x3e, 0x7f, 0x30, 0x23, 0xbf, 0x3e, 0x82, 0xfb, - 0x1e, 0x45, 0x25, 0x0a, 0xeb, 0x1b, 0x1f, 0x3a, 0x9e, 0x1e, 0xa7, 0x9f, 0x1e, 0xa1, 0x30, 0x4a, - 0xd1, 0x0e, 0x99, 0xa8, 0xff, 0xa3, 0x00, 0x4a, 0x0f, 0xc8, 0x5f, 0x9a, 0xae, 0x8a, 0x37, 0xbd, - 0x34, 0xb6, 0xea, 0xd4, 0x77, 0xe0, 0x84, 0x86, 0x1d, 0x17, 0xdb, 0xa1, 0xdf, 0x7b, 0xe0, 0x74, - 0x0f, 0x11, 0xb1, 0x9d, 0x84, 0x46, 0x16, 0x3d, 0x5f, 0x07, 0x0e, 0xa0, 0xb1, 0xb6, 0x8f, 0x3b, - 0x4f, 0x68, 0xf4, 0x7f, 0x94, 0x7c, 0x8e, 0x06, 0x94, 0x7b, 0x4e, 0x87, 0x3d, 0xbd, 0xc9, 0xb7, - 0x4a, 0xc4, 0xf7, 0x90, 0x5d, 0xea, 0x53, 0xb0, 0x92, 0x59, 0x2d, 0x97, 0x0a, 0x41, 0xfd, 0x1e, - 0x0e, 0x36, 0x9e, 0x62, 0x3b, 0x0c, 0x08, 0xd5, 0x1f, 0x16, 0x62, 0xa1, 0x27, 0x2d, 0x3a, 0x44, - 0x1e, 0x0c, 0x6a, 0xc3, 0x42, 0x84, 0x82, 0x09, 0x35, 0x7b, 0x08, 0x8f, 0x3d, 0x21, 0x99, 0x7d, - 0x46, 0x46, 0x2b, 0xa1, 0xef, 0xdf, 0x45, 0x4f, 0x7c, 0x84, 0xb0, 0xc4, 0xc9, 0x69, 0x31, 0x79, - 0x72, 0xfa, 0x3e, 0xa0, 0x78, 0x70, 0xc9, 0x57, 0x9b, 0xa5, 0x31, 0x5e, 0x35, 0xa9, 0xbb, 0xc9, - 0xf7, 0x77, 0x72, 0xde, 0x26, 0x99, 0x3c, 0xd2, 0xdb, 0x24, 0xea, 0x2a, 0x9c, 0x24, 0x21, 0xe3, - 0x43, 0x1c, 0x78, 0x56, 0x67, 0x1d, 0xfb, 0x1d, 0xcf, 0x72, 0x03, 0x27, 0x4c, 0xcd, 0x50, 0x75, - 0x38, 0x95, 0x53, 0xce, 0xd5, 0xfd, 0x0e, 0x54, 0xcd, 0x08, 0x9c, 0xb5, 0x72, 0x4f, 0xd2, 0x6a, - 0x71, 0x02, 0xf5, 0x03, 0xa8, 0x27, 0x11, 0x32, 0x33, 0x39, 0x11, 0x94, 0xf6, 0x71, 0xcf, 0x15, - 0x57, 0x53, 0xc8, 0x6f, 0xa2, 0x75, 0x16, 0x8d, 0x3f, 0xc1, 0x07, 0x62, 0x67, 0xb7, 0x42, 0x21, - 0x5f, 0xc4, 0x07, 0x61, 0xdb, 0xa4, 0xcb, 0xf2, 0x9e, 0xd5, 0x49, 0xb6, 0x2d, 0xa3, 0x3c, 0x6a, - 0x1b, 0xe9, 0xb6, 0x3e, 0x03, 0xf3, 0xb6, 0x9d, 0xca, 0xbd, 0x88, 0x4f, 0x69, 0xc1, 0x75, 0x4c, - 0xfe, 0x5b, 0xfd, 0x53, 0x05, 0xe6, 0x53, 0x18, 0x63, 0xee, 0xd6, 0xbf, 0x0a, 0xd3, 0xa2, 0xde, - 0x42, 0x3a, 0xdd, 0x91, 0xf1, 0xd2, 0x04, 0x0a, 0x6a, 0xc1, 0x7c, 0x64, 0xd1, 0x82, 0xae, 0x98, - 0xee, 0x8b, 0x78, 0x28, 0x4e, 0xc5, 0xad, 0x77, 0x12, 0x10, 0xb5, 0x03, 0xf5, 0x24, 0xd6, 0x38, - 0x63, 0xea, 0x50, 0xf2, 0xaa, 0x7f, 0xa7, 0xc0, 0x14, 0x83, 0x65, 0x76, 0xb6, 0xe4, 0xc5, 0x0b, - 0x49, 0x2f, 0xfe, 0x16, 0x54, 0x19, 0x1f, 0x3d, 0xbc, 0x98, 0x34, 0x2b, 0x6f, 0x58, 0x32, 0xd6, - 0x74, 0xb4, 0x42, 0x3f, 0xfc, 0x4d, 0x9a, 0xc1, 0xec, 0x85, 0xc6, 0xda, 0x22, 0xa9, 0xb5, 0x4a, - 0x61, 0xd4, 0xd7, 0x92, 0x78, 0x91, 0x47, 0xe5, 0x23, 0xe6, 0x41, 0x86, 0x75, 0xe1, 0x65, 0x28, - 0x8b, 0x47, 0x97, 0xd1, 0x34, 0x14, 0x77, 0xd6, 0xda, 0xf5, 0x09, 0xf2, 0x63, 0x77, 0xbd, 0x5d, - 0x57, 0x50, 0x19, 0x4a, 0xdb, 0x6b, 0x3b, 0xed, 0x7a, 0xe1, 0x42, 0x1f, 0xea, 0xc9, 0x77, 0x87, - 0xd1, 0x12, 0x1c, 0x6b, 0x6b, 0x5b, 0xed, 0xe6, 0xbd, 0xe6, 0x4e, 0x6b, 0x6b, 0x53, 0x6f, 0x6b, - 0xad, 0x47, 0xcd, 0x9d, 0x8d, 0xfa, 0x04, 0x3a, 0x0b, 0xa7, 0xe2, 0x05, 0xf7, 0xb7, 0xb6, 0x77, - 0xf4, 0x9d, 0x2d, 0x7d, 0x6d, 0x6b, 0x73, 0xa7, 0xd9, 0xda, 0xdc, 0xd0, 0xea, 0x0a, 0x3a, 0x05, - 0x27, 0xe2, 0x28, 0x77, 0x5b, 0xeb, 0x2d, 0x6d, 0x63, 0x8d, 0xfc, 0x6e, 0x3e, 0xa8, 0x17, 0x2e, - 0xbc, 0x0d, 0x35, 0xe9, 0x02, 0x03, 0x11, 0xa9, 0xbd, 0xb5, 0x5e, 0x9f, 0x40, 0x35, 0xa8, 0xc4, - 0xf9, 0x94, 0xa1, 0xb4, 0xb9, 0xb5, 0xbe, 0x51, 0x2f, 0x20, 0x80, 0xa9, 0x9d, 0xa6, 0x76, 0x6f, - 0x63, 0xa7, 0x5e, 0xbc, 0x70, 0x2b, 0xf9, 0x54, 0x02, 0x46, 0xf3, 0x50, 0xdb, 0x6e, 0x6e, 0xae, - 0xdf, 0xdd, 0xfa, 0x8a, 0xae, 0x6d, 0x34, 0xd7, 0x3f, 0xa8, 0x4f, 0xa0, 0x05, 0xa8, 0x0b, 0xd0, - 0xe6, 0xd6, 0x0e, 0x83, 0x2a, 0x17, 0x9e, 0x24, 0xd6, 0x2e, 0x18, 0x1d, 0x87, 0xf9, 0xb0, 0x4a, - 0x7d, 0x4d, 0xdb, 0x68, 0xee, 0x6c, 0x10, 0x49, 0x24, 0xb0, 0xb6, 0xbb, 0xb9, 0xd9, 0xda, 0xbc, - 0x57, 0x57, 0x08, 0xd7, 0x08, 0xbc, 0xf1, 0x95, 0x16, 0x41, 0x2e, 0xc8, 0xc8, 0xbb, 0x9b, 0x5f, - 0xdc, 0xdc, 0xfa, 0xf2, 0x66, 0xbd, 0x78, 0xe1, 0x57, 0xe3, 0x67, 0xeb, 0x91, 0x37, 0x5e, 0x81, - 0xa5, 0x54, 0x8d, 0xfa, 0xc6, 0xa3, 0x8d, 0xcd, 0x9d, 0xfa, 0x84, 0x5c, 0xb8, 0xbd, 0xd3, 0xd4, - 0xa2, 0x42, 0x25, 0x59, 0xb8, 0xd5, 0x6e, 0x87, 0x85, 0x05, 0xb9, 0x70, 0x7d, 0xe3, 0xc1, 0x46, - 0x44, 0x59, 0xbc, 0xf0, 0x22, 0x40, 0x64, 0x75, 0xa8, 0x0a, 0xd3, 0x6b, 0x5b, 0xbb, 0x9b, 0x3b, - 0x1b, 0x5a, 0x7d, 0x02, 0x55, 0x60, 0xf2, 0x5e, 0x73, 0xf7, 0xde, 0x46, 0x5d, 0xb9, 0xf6, 0xfb, - 0x0b, 0xe1, 0xdb, 0xa7, 0xdb, 0xd8, 0xa3, 0xb9, 0xe0, 0xeb, 0x30, 0x2d, 0xde, 0x1e, 0x97, 0x96, - 0xe4, 0xf2, 0x5b, 0xe9, 0x8d, 0x95, 0xcc, 0x32, 0x3e, 0x45, 0x4e, 0xa0, 0x47, 0x74, 0x43, 0x35, - 0xf6, 0xfa, 0xd0, 0x99, 0xc4, 0x26, 0x66, 0xea, 0x91, 0xa3, 0xc6, 0xd9, 0x21, 0x18, 0x21, 0xdf, - 0x0f, 0x60, 0x56, 0x7e, 0xe6, 0x0f, 0x9d, 0x95, 0x37, 0x3b, 0x33, 0x5e, 0x10, 0x6c, 0xa8, 0xc3, - 0x50, 0x42, 0xd6, 0x3a, 0xd4, 0x93, 0xcf, 0xfc, 0x21, 0x29, 0x87, 0x20, 0xe7, 0x15, 0xc1, 0xc6, - 0x8b, 0xc3, 0x91, 0xe2, 0x15, 0xa4, 0x5e, 0xaf, 0x7b, 0x61, 0xf8, 0x7b, 0x60, 0x19, 0x15, 0xe4, - 0x3d, 0x1a, 0xc6, 0x94, 0x23, 0x4f, 0x20, 0x28, 0xf1, 0x60, 0x5c, 0xc6, 0xdb, 0x52, 0xb2, 0x72, - 0xb2, 0xdf, 0x15, 0x52, 0x27, 0xd0, 0xff, 0x83, 0xb9, 0x44, 0xa2, 0x2f, 0x92, 0x08, 0xb3, 0xf3, - 0x97, 0x1b, 0x2f, 0x0c, 0xc5, 0x91, 0x7b, 0x35, 0x9e, 0xcc, 0x9b, 0xec, 0xd5, 0x8c, 0x24, 0xe1, - 0x64, 0xaf, 0x66, 0xe6, 0x02, 0x53, 0x43, 0x94, 0x12, 0x77, 0x65, 0x43, 0xcc, 0x4a, 0x14, 0x6e, - 0x9c, 0x1d, 0x82, 0x11, 0x57, 0x48, 0x22, 0x75, 0x57, 0x56, 0x48, 0x76, 0x52, 0x70, 0xe3, 0x85, - 0xa1, 0x38, 0xc9, 0x9e, 0x8c, 0x52, 0x06, 0xd3, 0x3d, 0x99, 0x4a, 0x5b, 0x4d, 0xf7, 0x64, 0x3a, - 0xe3, 0x90, 0xf7, 0x64, 0x22, 0xc9, 0x4f, 0x1d, 0x9a, 0x80, 0x94, 0xd5, 0x93, 0xd9, 0x49, 0x4a, - 0xea, 0x04, 0x7a, 0x06, 0xcb, 0x79, 0x79, 0x26, 0xe8, 0xe2, 0x21, 0xd2, 0x61, 0x1a, 0xaf, 0x8e, - 0x87, 0x1c, 0x56, 0x8c, 0x01, 0xa5, 0x57, 0x12, 0xe8, 0x25, 0x59, 0xdd, 0x39, 0x2b, 0x95, 0xc6, - 0xcb, 0xa3, 0xd0, 0xc2, 0x6a, 0xee, 0x41, 0x59, 0x64, 0xb0, 0x20, 0xc9, 0x05, 0x26, 0x32, 0x67, - 0x1a, 0x27, 0xb3, 0x0b, 0x43, 0x46, 0x5f, 0x80, 0x12, 0x81, 0xa2, 0xa5, 0x24, 0x9e, 0x60, 0xb0, - 0x9c, 0x2e, 0x08, 0x89, 0x9b, 0x30, 0xc5, 0x52, 0x33, 0x90, 0x74, 0x36, 0x24, 0xa5, 0x8e, 0x34, - 0x1a, 0x59, 0x45, 0x21, 0x8b, 0x36, 0xfb, 0x4f, 0x0e, 0x3c, 0xd3, 0x02, 0xad, 0x26, 0x1f, 0xf8, - 0x95, 0x53, 0x3a, 0x1a, 0xa7, 0x73, 0xcb, 0xe3, 0x36, 0x9b, 0xd8, 0x2d, 0x3b, 0x3b, 0x64, 0x4b, - 0x37, 0xcb, 0x66, 0xb3, 0x37, 0x8a, 0x59, 0xe7, 0xa6, 0x37, 0x92, 0xe5, 0xce, 0xcd, 0xdd, 0xac, - 0x97, 0x3b, 0x37, 0x7f, 0x3f, 0x9a, 0x0d, 0x8d, 0xe4, 0x4b, 0x3d, 0xea, 0xb0, 0x57, 0xb4, 0xb2, - 0x86, 0x46, 0xce, 0xeb, 0x5c, 0xea, 0x04, 0xda, 0x87, 0x63, 0x19, 0xcf, 0x77, 0xa1, 0x97, 0xf3, - 0xfd, 0xaf, 0x54, 0xcb, 0x2b, 0x23, 0xf1, 0xe2, 0x35, 0x65, 0x1c, 0xaf, 0xca, 0x35, 0xe5, 0x9f, - 0xef, 0xca, 0x35, 0x0d, 0x3b, 0xa7, 0xa5, 0x86, 0xc8, 0x7d, 0xc8, 0x89, 0xac, 0x33, 0xc7, 0x0c, - 0x43, 0x4c, 0x79, 0x8c, 0x7d, 0x38, 0x96, 0xb1, 0xda, 0x96, 0x85, 0xcd, 0xdf, 0x05, 0x90, 0x85, - 0x1d, 0xb6, 0x6c, 0x9f, 0x40, 0x5f, 0x05, 0x74, 0x0f, 0x07, 0x72, 0x7c, 0xe6, 0x23, 0x69, 0xa0, - 0x26, 0x17, 0xf6, 0x39, 0xf6, 0x29, 0xad, 0xf0, 0xd5, 0x89, 0xab, 0x0a, 0xb2, 0xd9, 0x5d, 0x82, - 0xd4, 0xba, 0x14, 0x9d, 0x4b, 0x76, 0x5b, 0xde, 0xd2, 0xb6, 0x71, 0x7e, 0x0c, 0xcc, 0xb0, 0x2d, - 0x76, 0xf2, 0xa9, 0x48, 0xb1, 0x34, 0x3a, 0x97, 0x6f, 0x26, 0xf2, 0x72, 0x33, 0x5d, 0x5f, 0xee, - 0xc2, 0x53, 0x9d, 0xb8, 0xf6, 0x3b, 0x45, 0x98, 0x61, 0xc9, 0x0b, 0x3c, 0x4c, 0x7c, 0x08, 0x10, - 0xe5, 0x01, 0xa1, 0x53, 0x49, 0x5e, 0x52, 0x72, 0x55, 0x63, 0x35, 0xaf, 0x38, 0xee, 0x8e, 0x62, - 0xf9, 0x35, 0xb2, 0x3b, 0x4a, 0xa7, 0x0b, 0xc9, 0xee, 0x28, 0x23, 0x31, 0x47, 0x9d, 0x40, 0xef, - 0x43, 0x25, 0x4c, 0xe7, 0x90, 0x3b, 0x39, 0x99, 0x97, 0xd2, 0x38, 0x95, 0x53, 0x1a, 0x97, 0x2e, - 0x96, 0xa5, 0x21, 0x4b, 0x97, 0xce, 0x00, 0x91, 0xa5, 0xcb, 0x4a, 0xef, 0x88, 0xda, 0xcb, 0xce, - 0x51, 0x33, 0xda, 0x2b, 0x1d, 0xab, 0x67, 0xb4, 0x57, 0x3e, 0x80, 0x55, 0x27, 0xee, 0xde, 0xf9, - 0xd1, 0x4f, 0x57, 0x95, 0x1f, 0xff, 0x74, 0x75, 0xe2, 0x57, 0x3e, 0x5a, 0x55, 0x7e, 0xf4, 0xd1, - 0xaa, 0xf2, 0x4f, 0x1f, 0xad, 0x2a, 0x3f, 0xf9, 0x68, 0x55, 0xf9, 0xf6, 0xbf, 0xaf, 0x4e, 0x7c, - 0x55, 0x7d, 0x72, 0xc3, 0xbf, 0x6c, 0x39, 0x57, 0x3a, 0x9e, 0x75, 0xc9, 0x70, 0xad, 0x2b, 0xee, - 0x93, 0xee, 0x15, 0xc3, 0xb5, 0xfc, 0x2b, 0x9c, 0xef, 0x95, 0xa7, 0xaf, 0x3d, 0x9e, 0xa2, 0xff, - 0xa5, 0xe7, 0xf5, 0xff, 0x0b, 0x00, 0x00, 0xff, 0xff, 0xdc, 0x7a, 0xda, 0x2e, 0x5f, 0x69, 0x00, - 0x00, + // 7123 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xd4, 0x7d, 0x5d, 0x6c, 0x1c, 0xc9, + 0x75, 0x2e, 0x7b, 0x66, 0x48, 0xce, 0x1c, 0x72, 0xc8, 0x61, 0x89, 0x22, 0xa9, 0x91, 0x44, 0x49, + 0xbd, 0x7f, 0x92, 0x76, 0xf5, 0xb3, 0x5a, 0xed, 0xae, 0xa4, 0xd5, 0xee, 0x6a, 0x44, 0x52, 0xda, + 0x59, 0x8b, 0xe4, 0xb8, 0x87, 0x5c, 0x7b, 0xd7, 0x17, 0xee, 0xdb, 0x9a, 0x2e, 0x0e, 0x7b, 0x35, + 0xd3, 0xdd, 0xee, 0xee, 0x91, 0x44, 0x3f, 0x5c, 0xdc, 0xa7, 0x8b, 0x1b, 0x3f, 0x19, 0x48, 0x8c, + 0x20, 0x46, 0x10, 0xc3, 0x01, 0x82, 0xe4, 0x2d, 0x89, 0x81, 0x38, 0x0e, 0x12, 0x20, 0x40, 0x90, + 0x18, 0x4e, 0x80, 0x00, 0x79, 0x48, 0x00, 0x3f, 0x04, 0x88, 0xbd, 0x09, 0x10, 0x20, 0xcf, 0x7e, + 0xc8, 0x53, 0x1c, 0xd4, 0x5f, 0x77, 0x57, 0xff, 0xcc, 0x0c, 0xb9, 0xca, 0xee, 0xfa, 0x89, 0xd3, + 0x55, 0xe7, 0x9c, 0xaa, 0x3a, 0x55, 0x75, 0xea, 0x9c, 0xaa, 0xaf, 0x8a, 0x50, 0x31, 0x5c, 0xeb, + 0xb2, 0xeb, 0x39, 0x81, 0x83, 0xc0, 0x1b, 0xd8, 0x81, 0xd5, 0xc7, 0x97, 0x1f, 0xbf, 0x5a, 0xbf, + 0xd4, 0xb5, 0x82, 0xfd, 0xc1, 0xc3, 0xcb, 0x1d, 0xa7, 0x7f, 0xa5, 0xeb, 0x74, 0x9d, 0x2b, 0x94, + 0xe4, 0xe1, 0x60, 0x8f, 0x7e, 0xd1, 0x0f, 0xfa, 0x8b, 0xb1, 0xaa, 0x17, 0x61, 0xee, 0x03, 0xec, + 0xf9, 0x96, 0x63, 0x6b, 0xf8, 0x1b, 0x03, 0xec, 0x07, 0x68, 0x05, 0xa6, 0x1f, 0xb3, 0x94, 0x15, + 0xe5, 0xac, 0x72, 0xbe, 0xa2, 0x89, 0x4f, 0xf5, 0xf7, 0x15, 0x98, 0x0f, 0x89, 0x7d, 0xd7, 0xb1, + 0x7d, 0x9c, 0x4f, 0x8d, 0xce, 0xc1, 0x2c, 0xaf, 0x96, 0x6e, 0x1b, 0x7d, 0xbc, 0x52, 0xa0, 0xd9, + 0x33, 0x3c, 0x6d, 0xcb, 0xe8, 0x63, 0xf4, 0x12, 0xcc, 0x0b, 0x12, 0x21, 0xa4, 0x48, 0xa9, 0xe6, + 0x78, 0x32, 0x2f, 0x0d, 0x5d, 0x86, 0x63, 0x82, 0xd0, 0x70, 0xad, 0x90, 0xb8, 0x44, 0x89, 0x17, + 0x78, 0x56, 0xc3, 0xb5, 0x38, 0xbd, 0xfa, 0x35, 0xa8, 0xac, 0x6f, 0xb5, 0xd7, 0x1c, 0x7b, 0xcf, + 0xea, 0x92, 0x2a, 0xfa, 0xd8, 0x23, 0x3c, 0x2b, 0xca, 0xd9, 0x22, 0xa9, 0x22, 0xff, 0x44, 0x75, + 0x28, 0xfb, 0xd8, 0xf0, 0x3a, 0xfb, 0xd8, 0x5f, 0x29, 0xd0, 0xac, 0xf0, 0x9b, 0x70, 0x39, 0x6e, + 0x60, 0x39, 0xb6, 0xbf, 0x52, 0x64, 0x5c, 0xfc, 0x53, 0xfd, 0x6d, 0x05, 0x66, 0x5a, 0x8e, 0x17, + 0x6c, 0x1a, 0xae, 0x6b, 0xd9, 0x5d, 0x74, 0x15, 0xca, 0x54, 0x97, 0x1d, 0xa7, 0x47, 0x75, 0x30, + 0x77, 0x6d, 0xf1, 0x72, 0xd4, 0x21, 0x97, 0x5b, 0x3c, 0x4f, 0x0b, 0xa9, 0xd0, 0x0b, 0x30, 0xd7, + 0x71, 0xec, 0xc0, 0xb0, 0x6c, 0xec, 0xe9, 0xae, 0xe3, 0x05, 0x54, 0x39, 0x93, 0x5a, 0x35, 0x4c, + 0x25, 0xf2, 0xd1, 0x49, 0xa8, 0xec, 0x3b, 0x7e, 0xc0, 0x28, 0x8a, 0x94, 0xa2, 0x4c, 0x12, 0x68, + 0xe6, 0x32, 0x4c, 0xd3, 0x4c, 0xcb, 0xe5, 0x6a, 0x98, 0x22, 0x9f, 0x4d, 0x57, 0xfd, 0x5e, 0x11, + 0x26, 0x37, 0x9d, 0x81, 0x1d, 0x24, 0x8a, 0x31, 0x82, 0x7d, 0xde, 0x45, 0xb1, 0x62, 0x8c, 0x60, + 0x3f, 0x2a, 0x86, 0x50, 0xb0, 0x5e, 0x62, 0xc5, 0x90, 0xcc, 0x3a, 0x94, 0x3d, 0x6c, 0x98, 0x8e, + 0xdd, 0x3b, 0xa0, 0x55, 0x28, 0x6b, 0xe1, 0x37, 0xe9, 0x3e, 0x1f, 0xf7, 0x2c, 0x7b, 0xf0, 0x54, + 0xf7, 0x70, 0xcf, 0x78, 0x88, 0x7b, 0xb4, 0x2a, 0x65, 0x6d, 0x8e, 0x27, 0x6b, 0x2c, 0x15, 0xbd, + 0x03, 0x33, 0xae, 0xe7, 0xb8, 0x46, 0xd7, 0x20, 0x1a, 0x5c, 0x99, 0xa4, 0x4a, 0x3a, 0x15, 0x57, + 0x12, 0xad, 0x70, 0x2b, 0xa2, 0xd1, 0xe2, 0x0c, 0xe8, 0x4d, 0x98, 0x19, 0x58, 0x26, 0xd7, 0xb7, + 0xbf, 0x32, 0x75, 0xb6, 0x78, 0x7e, 0xe6, 0xda, 0xf1, 0x38, 0x7f, 0x73, 0x9d, 0xe7, 0x6a, 0x71, + 0x4a, 0xc2, 0xd8, 0x8d, 0x31, 0x4e, 0x0f, 0x65, 0x8c, 0x51, 0xd2, 0x01, 0x87, 0x3b, 0x03, 0xcf, + 0xb7, 0x1e, 0x63, 0x9d, 0x34, 0x58, 0xa7, 0x1a, 0x28, 0xd3, 0xe6, 0x2d, 0x84, 0x59, 0x1a, 0x36, + 0xcc, 0x6d, 0xa2, 0x8a, 0x97, 0x61, 0xd2, 0xea, 0x1b, 0x5d, 0xbc, 0x52, 0x39, 0xab, 0xa4, 0x8a, + 0x20, 0x19, 0x6d, 0x17, 0x77, 0x34, 0x46, 0xa3, 0xea, 0x50, 0x09, 0x8b, 0x8d, 0xfa, 0xd1, 0xa4, + 0xbd, 0x53, 0xe5, 0xfd, 0x68, 0x92, 0xf9, 0x13, 0xf5, 0x9e, 0x65, 0xd2, 0x9e, 0xa9, 0x6a, 0x33, + 0x61, 0x5a, 0xd3, 0x44, 0x4b, 0x30, 0xd5, 0xc3, 0x76, 0x37, 0xd8, 0xa7, 0x5d, 0x53, 0xd5, 0xf8, + 0x97, 0xfa, 0x1b, 0x0a, 0x54, 0x77, 0x7d, 0xec, 0x91, 0x49, 0xe6, 0xbb, 0x46, 0x07, 0xa3, 0x4b, + 0x50, 0xea, 0x3b, 0x26, 0xe6, 0xe3, 0xf3, 0x44, 0xbc, 0x7a, 0x21, 0xd1, 0xa6, 0x63, 0x62, 0x8d, + 0x92, 0xa1, 0x0b, 0x50, 0x1a, 0x58, 0x26, 0x9b, 0x14, 0xb9, 0x0a, 0xa3, 0x24, 0x84, 0xb4, 0x4b, + 0x48, 0x8b, 0x43, 0x49, 0x09, 0x89, 0xfa, 0x4b, 0x05, 0xe6, 0xc3, 0xd2, 0xb6, 0xe9, 0x6c, 0x42, + 0xaf, 0xc1, 0xb4, 0x8d, 0x83, 0x27, 0x8e, 0xf7, 0x68, 0x74, 0xdd, 0x04, 0x25, 0x7a, 0x19, 0x8a, + 0x2e, 0xd7, 0xc8, 0x50, 0x06, 0x42, 0x45, 0x88, 0x2d, 0xb7, 0x43, 0x35, 0x34, 0x9c, 0xd8, 0x72, + 0x3b, 0x64, 0x2e, 0x04, 0x86, 0xd7, 0xc5, 0xb4, 0x3f, 0xd8, 0xbc, 0x2a, 0xb3, 0x84, 0xa6, 0x89, + 0xee, 0xc0, 0xdc, 0xc0, 0xc7, 0x9e, 0xed, 0xeb, 0xc2, 0x32, 0x4c, 0xd2, 0xde, 0x96, 0x84, 0x4a, + 0x7a, 0xd7, 0xaa, 0x8c, 0x61, 0x9b, 0x9b, 0x0e, 0x15, 0xa0, 0x69, 0x07, 0x6f, 0x5c, 0xff, 0xc0, + 0xe8, 0x0d, 0x30, 0x5a, 0x84, 0xc9, 0xc7, 0xe4, 0x07, 0x6d, 0x79, 0x51, 0x63, 0x1f, 0xea, 0xf7, + 0x27, 0xe1, 0xe4, 0x03, 0x32, 0x7b, 0xda, 0x86, 0x6d, 0x3e, 0x74, 0x9e, 0xb6, 0xc9, 0x60, 0xb3, + 0x82, 0x83, 0x35, 0xc7, 0x0e, 0xf0, 0xd3, 0x00, 0xbd, 0x07, 0x0b, 0xb6, 0x90, 0x1f, 0x56, 0x44, + 0xa1, 0x15, 0x39, 0x99, 0xd9, 0x3a, 0x56, 0xb8, 0x56, 0xb3, 0xe5, 0x04, 0x1f, 0xdd, 0x8d, 0xe6, + 0xaf, 0x90, 0x53, 0x48, 0x37, 0xa8, 0xbd, 0x41, 0x6b, 0xc3, 0xa5, 0x88, 0xa9, 0x2d, 0x64, 0xbc, + 0x01, 0xc4, 0xa2, 0xeb, 0x86, 0xaf, 0x93, 0x96, 0x52, 0x2d, 0xcf, 0x5c, 0x5b, 0x92, 0x46, 0x41, + 0xd8, 0x60, 0xad, 0xe2, 0x0d, 0xec, 0x86, 0x4f, 0x34, 0x84, 0x6e, 0xd0, 0xd5, 0x81, 0xf0, 0x75, + 0x3d, 0x67, 0xe0, 0xd2, 0x99, 0x95, 0xcf, 0x08, 0x94, 0xf1, 0x3e, 0xa1, 0xa4, 0x8b, 0x06, 0xb7, + 0x40, 0xba, 0xe7, 0x38, 0xc1, 0x9e, 0x2f, 0xac, 0x8e, 0x48, 0xd6, 0x68, 0x2a, 0xba, 0x02, 0xc7, + 0xfc, 0x81, 0xeb, 0xf6, 0x70, 0x1f, 0xdb, 0x81, 0xd1, 0x63, 0x05, 0x91, 0x3e, 0x2b, 0x9e, 0x2f, + 0x6a, 0x28, 0x9e, 0x45, 0x05, 0xfb, 0xe8, 0x21, 0xd4, 0x33, 0x18, 0x74, 0xd7, 0xe9, 0x59, 0x9d, + 0x83, 0x95, 0x19, 0x3a, 0x80, 0x9e, 0x97, 0x54, 0x93, 0x92, 0xd1, 0xa2, 0xb4, 0xda, 0x8a, 0x9f, + 0x93, 0x83, 0x56, 0x01, 0x5c, 0xcf, 0x7a, 0x6c, 0xf5, 0x70, 0x17, 0x9b, 0x2b, 0x53, 0xb4, 0xe2, + 0xb1, 0x14, 0xf4, 0x3a, 0x59, 0xac, 0x3a, 0x1d, 0xa7, 0xef, 0x72, 0x53, 0x22, 0xf5, 0xa9, 0x18, + 0x0b, 0x2d, 0xcf, 0xd9, 0xb3, 0x7a, 0x58, 0x13, 0xb4, 0xe8, 0x4d, 0x28, 0x1b, 0xae, 0x6b, 0x78, + 0x7d, 0xc7, 0x5b, 0x81, 0xd1, 0x7c, 0x21, 0x31, 0xba, 0x0e, 0x8b, 0x5c, 0x86, 0xee, 0xb2, 0x4c, + 0xb6, 0x0e, 0x4c, 0x93, 0xb1, 0x7f, 0xb7, 0xb0, 0xa2, 0x68, 0x88, 0xe7, 0x73, 0x5e, 0xb2, 0x2a, + 0xa8, 0x7f, 0xad, 0xc0, 0x7c, 0x42, 0x26, 0x7a, 0x1f, 0x66, 0x85, 0x84, 0xe0, 0xc0, 0x15, 0xa6, + 0xe6, 0xa5, 0x21, 0xd5, 0xb8, 0xcc, 0xff, 0xee, 0x1c, 0xb8, 0x98, 0x1a, 0x7c, 0xf1, 0x81, 0x9e, + 0x83, 0x6a, 0xcf, 0xe9, 0x18, 0x3d, 0x6a, 0x19, 0x3d, 0xbc, 0xc7, 0x97, 0xa5, 0xd9, 0x30, 0x51, + 0xc3, 0x7b, 0xea, 0x1d, 0x98, 0x89, 0x09, 0x40, 0x08, 0xe6, 0x34, 0x56, 0xd4, 0x3a, 0xde, 0x33, + 0x06, 0xbd, 0xa0, 0x36, 0x81, 0xe6, 0x00, 0x76, 0xed, 0x0e, 0x71, 0x03, 0x6c, 0x6c, 0xd6, 0x14, + 0x54, 0x85, 0xca, 0x03, 0x21, 0xa2, 0x56, 0x50, 0xbf, 0x5b, 0x84, 0xe3, 0x74, 0x70, 0xb7, 0x1c, + 0x93, 0xcf, 0x36, 0xee, 0x33, 0x3c, 0x07, 0xd5, 0x0e, 0xed, 0x7e, 0xdd, 0x35, 0x3c, 0x6c, 0x07, + 0x7c, 0xe5, 0x9c, 0x65, 0x89, 0x2d, 0x9a, 0x86, 0x34, 0xa8, 0xf9, 0xbc, 0x45, 0x7a, 0x87, 0xcd, + 0x4e, 0x3e, 0x81, 0xa4, 0x56, 0x0f, 0x99, 0xcc, 0xda, 0xbc, 0x9f, 0x9a, 0xdd, 0xd3, 0xfe, 0x81, + 0xdf, 0x09, 0x7a, 0xc2, 0xa2, 0x5e, 0x4e, 0x89, 0x4a, 0x56, 0xf6, 0x72, 0x9b, 0x31, 0x6c, 0xd8, + 0x81, 0x77, 0xa0, 0x09, 0x76, 0xf4, 0x2e, 0x94, 0x9d, 0xc7, 0xd8, 0xdb, 0xc7, 0x06, 0xb3, 0x64, + 0x33, 0xd7, 0x9e, 0x4b, 0x89, 0x5a, 0x13, 0x8b, 0x89, 0x86, 0x7d, 0x67, 0xe0, 0x75, 0xb0, 0xaf, + 0x85, 0x4c, 0xa8, 0x01, 0x15, 0x4f, 0x24, 0x73, 0x4b, 0x37, 0x96, 0x84, 0x88, 0xab, 0x7e, 0x0b, + 0x66, 0xe3, 0x95, 0x43, 0x35, 0x28, 0x3e, 0xc2, 0x07, 0x5c, 0x99, 0xe4, 0x67, 0x64, 0x03, 0x59, + 0x0f, 0xb3, 0x8f, 0x5b, 0x85, 0x1b, 0x8a, 0xea, 0x01, 0x8a, 0x5a, 0xba, 0x89, 0x03, 0xc3, 0x34, + 0x02, 0x03, 0x21, 0x28, 0x51, 0x6f, 0x92, 0x89, 0xa0, 0xbf, 0x89, 0xd4, 0x01, 0x5f, 0x0e, 0x2a, + 0x1a, 0xf9, 0x89, 0x4e, 0x41, 0x25, 0xb4, 0x76, 0xdc, 0xa5, 0x8c, 0x12, 0x88, 0x6b, 0x67, 0x04, + 0x01, 0xee, 0xbb, 0x01, 0x55, 0x4c, 0x55, 0x13, 0x9f, 0xea, 0xaf, 0x4d, 0x42, 0x2d, 0x35, 0x16, + 0x6e, 0x41, 0xb9, 0xcf, 0x8b, 0xe7, 0x76, 0x76, 0x55, 0xf2, 0xef, 0x52, 0x95, 0xd4, 0x42, 0x7a, + 0xe2, 0x3e, 0x91, 0xb1, 0x16, 0x73, 0x80, 0xc3, 0x6f, 0x36, 0xc8, 0xbb, 0xba, 0x69, 0x79, 0xb8, + 0x13, 0x38, 0xde, 0x01, 0xaf, 0xe8, 0x6c, 0xcf, 0xe9, 0xae, 0x8b, 0x34, 0x74, 0x1d, 0xc0, 0xb4, + 0x7d, 0x9d, 0x8e, 0xe1, 0x2e, 0xef, 0x47, 0x69, 0x91, 0x0d, 0xfd, 0x5c, 0xad, 0x62, 0xda, 0x3e, + 0xaf, 0xf2, 0x6d, 0xa8, 0x12, 0xa7, 0x51, 0xef, 0x0b, 0xcf, 0x67, 0x92, 0x8e, 0xa5, 0x65, 0xb9, + 0xde, 0xa1, 0x0b, 0xab, 0xcd, 0xba, 0xd1, 0x87, 0x8f, 0xee, 0xc0, 0x14, 0xf5, 0xdb, 0x84, 0xa7, + 0x75, 0x3e, 0xbb, 0xb9, 0x7c, 0xf4, 0x3d, 0xa0, 0xa4, 0x6c, 0xf0, 0x71, 0x3e, 0xb4, 0x0d, 0x33, + 0x86, 0x6d, 0x3b, 0x81, 0xc1, 0x56, 0x15, 0xe6, 0x77, 0x5d, 0x1a, 0x2a, 0xa6, 0x11, 0xd1, 0x33, + 0x59, 0x71, 0x09, 0xe8, 0x4d, 0x98, 0xa4, 0xcb, 0x0e, 0x5f, 0x27, 0xce, 0x8d, 0x9c, 0x14, 0x1a, + 0xa3, 0x47, 0x6f, 0xc3, 0xf4, 0x13, 0xcb, 0x36, 0x9d, 0x27, 0x3e, 0xb7, 0xa7, 0xd2, 0x10, 0xfe, + 0x0a, 0xcb, 0x4a, 0x31, 0x0b, 0x9e, 0xfa, 0x4d, 0x98, 0x89, 0xb5, 0xef, 0x30, 0xe3, 0xb7, 0xfe, + 0x0e, 0xd4, 0x92, 0x6d, 0x3a, 0xd4, 0xf8, 0x1f, 0xc0, 0xa2, 0x36, 0xb0, 0xa3, 0xaa, 0x89, 0xf8, + 0xec, 0x3a, 0x4c, 0xf1, 0xd1, 0xc0, 0x06, 0xe3, 0xa9, 0x61, 0x6a, 0xd5, 0x38, 0x6d, 0x3c, 0xd4, + 0xda, 0x37, 0x6c, 0xb3, 0x87, 0x3d, 0x5e, 0xa2, 0x08, 0xb5, 0xde, 0x63, 0xa9, 0xea, 0xdb, 0x70, + 0x3c, 0x51, 0x2c, 0x8f, 0xf4, 0x9e, 0x87, 0x39, 0xd7, 0x31, 0x75, 0x9f, 0x25, 0x0b, 0x7f, 0xb5, + 0x42, 0xc6, 0x8e, 0xa0, 0x6d, 0x9a, 0x84, 0xbd, 0x1d, 0x38, 0x6e, 0xba, 0xda, 0xe3, 0xb1, 0xaf, + 0xc0, 0x52, 0x92, 0x9d, 0x15, 0xaf, 0xbe, 0x0b, 0xcb, 0x1a, 0xee, 0x3b, 0x8f, 0xf1, 0x51, 0x45, + 0xd7, 0x61, 0x25, 0x2d, 0x80, 0x0b, 0xff, 0x10, 0x96, 0xa3, 0xd4, 0x76, 0x60, 0x04, 0x03, 0xff, + 0x50, 0xc2, 0x79, 0x18, 0xfc, 0xd0, 0xf1, 0x59, 0x47, 0x96, 0x35, 0xf1, 0xa9, 0x2e, 0xc3, 0x64, + 0xcb, 0x31, 0x9b, 0x2d, 0x34, 0x07, 0x05, 0xcb, 0xe5, 0xcc, 0x05, 0xcb, 0x55, 0x3b, 0xf1, 0x32, + 0xb7, 0x98, 0x67, 0xcb, 0x8a, 0x4e, 0x92, 0xa2, 0x1b, 0x30, 0x67, 0x98, 0xa6, 0x45, 0x06, 0x92, + 0xd1, 0xd3, 0x2d, 0x57, 0x38, 0xe6, 0x0b, 0x89, 0xae, 0x6f, 0xb6, 0xb4, 0x6a, 0x44, 0xd8, 0x74, + 0x7d, 0xf5, 0x2e, 0x54, 0xa2, 0x20, 0xe0, 0xf5, 0x28, 0xa4, 0x2d, 0x8c, 0xf6, 0x17, 0xc3, 0x78, + 0x77, 0x2b, 0xb5, 0x48, 0xf2, 0x6a, 0xbe, 0x0e, 0x10, 0x1a, 0x55, 0xe1, 0x82, 0x1e, 0xcf, 0x14, + 0xa9, 0xc5, 0x08, 0xd5, 0x7f, 0x29, 0xc5, 0x8d, 0x6c, 0xac, 0xc9, 0x66, 0xd8, 0x64, 0x53, 0x32, + 0xba, 0x85, 0x43, 0x1a, 0xdd, 0x57, 0x61, 0xd2, 0x0f, 0x8c, 0x00, 0x73, 0x9f, 0xff, 0x64, 0x36, + 0x23, 0x29, 0x18, 0x6b, 0x8c, 0x12, 0x9d, 0x06, 0xe8, 0x78, 0xd8, 0x08, 0xb0, 0xa9, 0x1b, 0x6c, + 0x55, 0x28, 0x6a, 0x15, 0x9e, 0xd2, 0x08, 0x88, 0x15, 0x11, 0x51, 0x4a, 0xc6, 0x42, 0x98, 0xd3, + 0x8d, 0x51, 0xbc, 0x12, 0x5a, 0xaf, 0xa9, 0x91, 0xd6, 0x8b, 0xb3, 0x72, 0xeb, 0x15, 0x59, 0xe2, + 0xe9, 0x61, 0x96, 0x98, 0x31, 0x8d, 0x63, 0x89, 0xcb, 0xc3, 0x2c, 0x31, 0x17, 0x33, 0xdc, 0x12, + 0x67, 0x18, 0x92, 0x4a, 0x96, 0x21, 0xf9, 0x3c, 0x4d, 0xe7, 0x9f, 0x15, 0x60, 0x25, 0x3d, 0x9f, + 0xb9, 0x1d, 0xbb, 0x0e, 0x53, 0x3e, 0x4d, 0x19, 0x6e, 0x3f, 0x39, 0x17, 0xa7, 0x45, 0x77, 0xa1, + 0x64, 0xd9, 0x7b, 0x0e, 0x9f, 0x78, 0x97, 0x87, 0xf2, 0xf0, 0x92, 0x2e, 0x37, 0xed, 0x3d, 0x87, + 0x69, 0x90, 0xf2, 0xa2, 0x07, 0x70, 0x2c, 0x8c, 0xde, 0x7d, 0x9d, 0x09, 0xc6, 0xc2, 0xcf, 0x93, + 0x46, 0x69, 0xe8, 0x55, 0x71, 0x89, 0x28, 0xe2, 0x6b, 0x73, 0x36, 0xe2, 0xe3, 0x10, 0x72, 0x3f, + 0x30, 0xfa, 0xae, 0x18, 0xb1, 0x61, 0x42, 0xfd, 0x4d, 0xa8, 0x84, 0xc5, 0x1f, 0x4a, 0x77, 0x4d, + 0x58, 0x4c, 0xcc, 0x11, 0x16, 0xac, 0x86, 0x93, 0x4a, 0x19, 0x77, 0x52, 0xa9, 0xbf, 0x50, 0xe2, + 0x13, 0xfd, 0x9e, 0xd5, 0x0b, 0xb0, 0x97, 0x9a, 0xe8, 0x6f, 0x08, 0xb9, 0x6c, 0x96, 0x9f, 0x1d, + 0x22, 0x97, 0xc5, 0x82, 0x7c, 0xc6, 0x7e, 0x00, 0x73, 0x74, 0x88, 0xeb, 0x3e, 0xee, 0x51, 0x5f, + 0x89, 0xeb, 0xf1, 0x4a, 0xb6, 0x00, 0x56, 0x3a, 0x9b, 0x22, 0x6d, 0xce, 0xc1, 0xfa, 0xa6, 0xda, + 0x8b, 0xa7, 0xd5, 0xef, 0x00, 0x4a, 0x13, 0x1d, 0x4a, 0x83, 0x9b, 0xc4, 0x5e, 0xfa, 0x41, 0xe6, + 0xca, 0xbd, 0x47, 0xab, 0x31, 0x7c, 0xe4, 0xb1, 0xaa, 0x6a, 0x9c, 0x56, 0xfd, 0xa7, 0x22, 0x40, + 0x94, 0xf9, 0x05, 0x37, 0x94, 0xb7, 0x42, 0x83, 0xc5, 0x3c, 0x4e, 0x35, 0x5b, 0x64, 0xa6, 0xa9, + 0x6a, 0xca, 0xa6, 0x8a, 0xf9, 0x9e, 0x2f, 0xe5, 0x08, 0x38, 0xb4, 0x91, 0x9a, 0xfe, 0xa2, 0x19, + 0xa9, 0x7b, 0xb0, 0x94, 0x1c, 0x26, 0xdc, 0x42, 0xbd, 0x02, 0x93, 0x56, 0x80, 0xfb, 0x6c, 0xbb, + 0x3a, 0xb1, 0x29, 0x12, 0x23, 0x67, 0x44, 0xea, 0x3b, 0xb0, 0x24, 0xf7, 0xd5, 0xe1, 0x5c, 0x17, + 0xf5, 0x41, 0xd2, 0xf7, 0x89, 0x4c, 0x25, 0x1f, 0x1f, 0x99, 0xdb, 0x4b, 0x49, 0x1e, 0x46, 0xa9, + 0xfe, 0x58, 0x81, 0xe3, 0x89, 0xac, 0x9c, 0x89, 0xff, 0xb5, 0xd4, 0x04, 0x66, 0xb6, 0xf5, 0xfa, + 0x90, 0x52, 0x3e, 0xc3, 0x59, 0xfc, 0x15, 0xa8, 0xcb, 0xdd, 0x23, 0xa9, 0xf6, 0x66, 0x62, 0x2a, + 0x9f, 0x1b, 0x59, 0xe9, 0x70, 0x3e, 0xb7, 0xe0, 0x64, 0xa6, 0xe0, 0xb4, 0xce, 0x8b, 0x63, 0xea, + 0xfc, 0x3f, 0x0b, 0x71, 0x9b, 0xdd, 0x08, 0x02, 0xcf, 0x7a, 0x38, 0x08, 0xf0, 0xb3, 0x75, 0xaa, + 0xd6, 0xc3, 0x99, 0xcd, 0xec, 0xec, 0x2b, 0xd9, 0x9c, 0x51, 0xe9, 0x99, 0x73, 0xbc, 0x2d, 0xcf, + 0xf1, 0x12, 0x15, 0xf5, 0xea, 0x48, 0x51, 0x43, 0x67, 0xfb, 0xe7, 0x39, 0x89, 0xff, 0x56, 0x81, + 0xf9, 0x44, 0xaf, 0xa0, 0x3b, 0x00, 0x46, 0x58, 0x75, 0x3e, 0x3e, 0xce, 0x8e, 0x6a, 0xa2, 0x16, + 0xe3, 0x21, 0x6b, 0x22, 0xf3, 0x17, 0x33, 0xd6, 0xc4, 0x0c, 0x7f, 0x31, 0x74, 0x17, 0x6f, 0x47, + 0xc1, 0x2e, 0xdb, 0x88, 0x55, 0x87, 0x06, 0xbb, 0x8c, 0x57, 0xb0, 0xa8, 0xbf, 0x5e, 0x80, 0xc5, + 0x2c, 0xe9, 0xe8, 0x45, 0x28, 0x76, 0xdc, 0x01, 0x6f, 0x89, 0x74, 0xb6, 0xb5, 0xe6, 0x0e, 0x76, + 0x7d, 0xa3, 0x8b, 0x35, 0x42, 0x80, 0xae, 0xc0, 0x54, 0x1f, 0xf7, 0x1d, 0xef, 0x80, 0xd7, 0x5b, + 0xda, 0x6e, 0xd8, 0xa4, 0x39, 0x8c, 0x9a, 0x93, 0xa1, 0x6b, 0x91, 0x5b, 0xcd, 0xea, 0xbb, 0x22, + 0x45, 0x0f, 0x2c, 0x8b, 0xb1, 0x84, 0xbe, 0xf4, 0x35, 0x98, 0x76, 0x3d, 0xa7, 0x83, 0x7d, 0x9f, + 0xef, 0x86, 0xac, 0x24, 0x0e, 0xdb, 0x48, 0x16, 0xe7, 0xe1, 0x84, 0xe8, 0x16, 0x40, 0xe4, 0x40, + 0xf1, 0x95, 0xa9, 0x9e, 0xeb, 0x6f, 0xf9, 0x5a, 0x8c, 0x5a, 0xfd, 0x51, 0x01, 0x96, 0xb2, 0x35, + 0x87, 0x2e, 0xc5, 0xf5, 0x72, 0x32, 0x43, 0xd5, 0xb2, 0x7a, 0xde, 0x48, 0xa8, 0x67, 0x35, 0x83, + 0x23, 0x4b, 0x4b, 0x37, 0x93, 0x5a, 0x3a, 0x93, 0xc1, 0x98, 0xad, 0xac, 0x9b, 0x49, 0x65, 0x65, + 0xb1, 0x66, 0xeb, 0xac, 0x91, 0xa1, 0xb3, 0x73, 0x59, 0x6d, 0xcc, 0x57, 0xdd, 0x5f, 0x2a, 0x30, + 0x1b, 0xaf, 0x97, 0xec, 0xb2, 0x2a, 0x09, 0x97, 0x15, 0x6d, 0xc1, 0x82, 0xc9, 0x76, 0x6e, 0x75, + 0xcb, 0x0e, 0xb0, 0xb7, 0x67, 0x74, 0x84, 0x57, 0x78, 0x2e, 0x63, 0x5c, 0x34, 0x05, 0x0d, 0xab, + 0x78, 0x8d, 0xf3, 0x86, 0xc9, 0xa4, 0x05, 0xa1, 0x1c, 0x61, 0xb5, 0xc6, 0x10, 0x14, 0x63, 0x52, + 0xff, 0x51, 0x81, 0x63, 0x19, 0x0a, 0x1e, 0xd1, 0x90, 0xdd, 0xfc, 0x86, 0x9c, 0xcf, 0xef, 0xba, + 0x91, 0xed, 0x79, 0x2f, 0xa3, 0x3d, 0xe3, 0xcb, 0x8b, 0x37, 0xeb, 0x97, 0x0a, 0x1c, 0xcf, 0xa4, + 0xca, 0xdc, 0x5e, 0xbd, 0x06, 0x65, 0xef, 0xa9, 0xfe, 0xf0, 0x20, 0xc0, 0x7e, 0xd6, 0xc4, 0xde, + 0x8d, 0x9d, 0xd3, 0x4c, 0x7b, 0x4f, 0xef, 0x12, 0x3a, 0x74, 0x1d, 0x2a, 0xde, 0x53, 0x1d, 0x7b, + 0x9e, 0xe3, 0x09, 0x5b, 0x94, 0xcb, 0x54, 0xf6, 0x9e, 0x6e, 0x50, 0x42, 0x52, 0x52, 0x20, 0x4a, + 0x2a, 0x8d, 0x28, 0x29, 0x88, 0x4a, 0x0a, 0xc2, 0x92, 0x26, 0x47, 0x94, 0x14, 0xf0, 0x92, 0xd4, + 0x3f, 0x28, 0xc0, 0xa9, 0x61, 0xea, 0x7a, 0x66, 0x8a, 0xd8, 0x00, 0xe4, 0x3d, 0xd5, 0x5d, 0xa3, + 0xf3, 0x08, 0x07, 0xbe, 0x6e, 0x7a, 0x8e, 0xeb, 0x62, 0x73, 0x94, 0x46, 0x6a, 0xde, 0xd3, 0x16, + 0xe3, 0x58, 0x67, 0x0c, 0x47, 0xd2, 0xcc, 0x06, 0xa0, 0x20, 0x5d, 0xf4, 0x08, 0x15, 0xd5, 0x82, + 0x44, 0xd1, 0xea, 0xc7, 0x30, 0x1b, 0xb7, 0x10, 0x23, 0xc6, 0xfe, 0x6d, 0xa8, 0x72, 0x0b, 0xa2, + 0x77, 0x9c, 0x81, 0x1d, 0x8c, 0x52, 0xd4, 0x2c, 0xa7, 0x5e, 0x23, 0xc4, 0xea, 0x37, 0xc2, 0xe9, + 0xf6, 0x99, 0x15, 0xf9, 0xff, 0x0a, 0x50, 0x09, 0x4f, 0xe8, 0xc9, 0x4a, 0xcf, 0xce, 0xf1, 0x59, + 0xbf, 0xb3, 0x0f, 0xf4, 0x9e, 0xec, 0xb5, 0x30, 0x3f, 0xf5, 0xc5, 0xcc, 0x33, 0xfe, 0x11, 0x81, + 0xc9, 0x55, 0x58, 0x1c, 0xf8, 0xd8, 0xd3, 0x7d, 0x17, 0x77, 0xac, 0x3d, 0x0b, 0x9b, 0x3a, 0x2b, + 0x0e, 0xd1, 0xe2, 0x10, 0xc9, 0x6b, 0x8b, 0x2c, 0x2a, 0x33, 0x2b, 0x94, 0x39, 0x96, 0x19, 0xca, + 0x7c, 0x5a, 0x57, 0xe6, 0x1a, 0x94, 0xbf, 0x84, 0x0f, 0x58, 0xb0, 0x3f, 0x26, 0x9f, 0xfa, 0x9d, + 0x12, 0x2c, 0xe7, 0x1c, 0x03, 0xd1, 0x48, 0xd1, 0x1d, 0xe8, 0x2e, 0xf6, 0x2c, 0xc7, 0x14, 0xbd, + 0xd6, 0x71, 0x07, 0x2d, 0x9a, 0x80, 0x4e, 0x02, 0xf9, 0xd0, 0xbf, 0x31, 0x70, 0xb8, 0x33, 0x5a, + 0xd4, 0xca, 0x1d, 0x77, 0xf0, 0x65, 0xf2, 0x2d, 0x78, 0xfd, 0x7d, 0xc3, 0xc3, 0xcc, 0x7e, 0x30, + 0xde, 0x36, 0x4d, 0x40, 0xaf, 0xc2, 0x71, 0xb6, 0x36, 0xea, 0x3d, 0xab, 0x6f, 0x11, 0x2b, 0x1b, + 0x9b, 0x1a, 0x45, 0x0d, 0xb1, 0xcc, 0x07, 0x24, 0xaf, 0x69, 0xb3, 0xc9, 0xa0, 0x42, 0xd5, 0x71, + 0xfa, 0xba, 0xdf, 0x71, 0x3c, 0xac, 0x1b, 0xe6, 0xc7, 0x74, 0x1e, 0x14, 0xb5, 0x19, 0xc7, 0xe9, + 0xb7, 0x49, 0x5a, 0xc3, 0xfc, 0x18, 0x9d, 0x81, 0x99, 0x8e, 0x3b, 0xf0, 0x71, 0xa0, 0x93, 0x3f, + 0x74, 0xb3, 0xae, 0xa2, 0x01, 0x4b, 0x5a, 0x73, 0x07, 0x7e, 0x8c, 0xa0, 0x4f, 0xc2, 0xb3, 0xe9, + 0x38, 0xc1, 0x26, 0xee, 0xd3, 0x13, 0xf5, 0xfd, 0x41, 0x17, 0xbb, 0x46, 0x17, 0xb3, 0xaa, 0x89, + 0x1d, 0x37, 0xe9, 0x44, 0xfd, 0x3d, 0x4e, 0x42, 0x2b, 0xa8, 0xcd, 0xed, 0xc7, 0x3f, 0x7d, 0xf4, + 0x3e, 0x4c, 0x0f, 0x6c, 0x3a, 0x00, 0x56, 0x2a, 0x94, 0xf7, 0xea, 0x18, 0x87, 0x6e, 0x97, 0x77, + 0x19, 0x0b, 0x3f, 0x03, 0xe4, 0x02, 0xd0, 0x2d, 0xa8, 0x73, 0x45, 0xf9, 0x4f, 0x0c, 0x37, 0xa9, + 0x2d, 0xa0, 0x2a, 0x58, 0x62, 0x14, 0xed, 0x27, 0x86, 0x1b, 0xd7, 0x58, 0xfd, 0x16, 0xcc, 0xc6, + 0x85, 0x1e, 0x6a, 0x2c, 0xdd, 0x85, 0xaa, 0xd4, 0x48, 0xd2, 0xdb, 0x54, 0x29, 0xbe, 0xf5, 0x4d, + 0x31, 0xb7, 0xca, 0x24, 0xa1, 0x6d, 0x7d, 0x93, 0xe2, 0x20, 0x68, 0xcd, 0xa8, 0x9c, 0x92, 0xc6, + 0x3e, 0x54, 0x03, 0xaa, 0x12, 0xf4, 0x80, 0x98, 0x64, 0x8a, 0x31, 0xe0, 0x26, 0x99, 0xfc, 0x26, + 0x69, 0x9e, 0xd3, 0x13, 0x35, 0xa0, 0xbf, 0x49, 0x1a, 0x3d, 0x80, 0x66, 0xc7, 0x69, 0xf4, 0x37, + 0x2d, 0x02, 0x3f, 0xe6, 0x00, 0xa5, 0x8a, 0xc6, 0x3e, 0xd4, 0xdf, 0x51, 0x00, 0xd6, 0x0c, 0xd7, + 0x78, 0x68, 0xf5, 0xac, 0xe0, 0x00, 0x5d, 0x80, 0x9a, 0x61, 0x9a, 0x7a, 0x47, 0xa4, 0x58, 0x58, + 0x20, 0xc6, 0xe6, 0x0d, 0xd3, 0x5c, 0x8b, 0x25, 0xa3, 0x97, 0x61, 0x81, 0x18, 0x54, 0x99, 0x96, + 0x41, 0xc8, 0x6a, 0x24, 0x43, 0x22, 0xbe, 0x01, 0x2b, 0x44, 0xae, 0xd1, 0x7f, 0x68, 0x61, 0x3b, + 0x90, 0x79, 0x18, 0xb6, 0x6c, 0xc9, 0x30, 0xcd, 0x06, 0xcb, 0x8e, 0x73, 0xaa, 0xbf, 0x3b, 0x0d, + 0xa7, 0xe5, 0x1e, 0x4f, 0xa2, 0x41, 0x6e, 0xc1, 0x6c, 0xa2, 0xbe, 0x29, 0x1c, 0x45, 0xd4, 0x42, + 0x4d, 0xa2, 0x4d, 0x60, 0x11, 0x0a, 0x29, 0x2c, 0x42, 0x26, 0xd2, 0xa4, 0xf8, 0x8c, 0x90, 0x26, + 0xa5, 0x4f, 0x89, 0x34, 0x99, 0x3c, 0x2a, 0xd2, 0x64, 0x76, 0x6c, 0xa4, 0xc9, 0x8b, 0xd4, 0xf4, + 0x8a, 0x12, 0xa9, 0x3b, 0xc0, 0x6c, 0x42, 0x35, 0x94, 0x6e, 0x0b, 0x18, 0x63, 0x02, 0x91, 0x32, + 0x7d, 0x18, 0x44, 0x4a, 0xf9, 0x88, 0x88, 0x94, 0x85, 0x67, 0x82, 0x48, 0x39, 0x0b, 0xb3, 0xb6, + 0xa3, 0xdb, 0xf8, 0x89, 0x4e, 0xba, 0xde, 0xa7, 0x38, 0x97, 0xb2, 0x06, 0xb6, 0xb3, 0x85, 0x9f, + 0xb4, 0x48, 0x0a, 0x3a, 0x07, 0xb3, 0x7d, 0xc3, 0x7f, 0x84, 0x4d, 0x0a, 0x0d, 0xf1, 0x57, 0xaa, + 0x74, 0xcc, 0xce, 0xb0, 0xb4, 0x16, 0x49, 0x42, 0x2f, 0x40, 0xd8, 0x56, 0x4e, 0x34, 0x47, 0x89, + 0xaa, 0x22, 0x95, 0x91, 0xc5, 0xd0, 0x2d, 0xf3, 0x47, 0x44, 0xb7, 0xd4, 0x0e, 0x83, 0x6e, 0xb9, + 0x04, 0x35, 0xf1, 0x5b, 0xc0, 0x5b, 0xd8, 0x69, 0x05, 0x45, 0xb6, 0xcc, 0x8b, 0x3c, 0x01, 0x61, + 0xc9, 0x03, 0xc3, 0xc0, 0x50, 0x30, 0xcc, 0x1f, 0x2a, 0x3c, 0x6e, 0x0e, 0x27, 0x29, 0x3f, 0x85, + 0x97, 0x00, 0x14, 0xca, 0x51, 0x00, 0x14, 0x68, 0x27, 0x17, 0x62, 0x72, 0x21, 0x5f, 0xd2, 0x28, + 0x90, 0x89, 0x6a, 0x01, 0x92, 0x39, 0xe8, 0x44, 0xe1, 0x30, 0x0a, 0xb6, 0x52, 0x53, 0x18, 0x45, + 0x0d, 0x8a, 0x5d, 0x0e, 0xac, 0x28, 0x6a, 0xe4, 0x67, 0xde, 0x08, 0x2e, 0xe6, 0x8d, 0x60, 0x75, + 0x33, 0x8c, 0x9e, 0x9f, 0x05, 0xf2, 0x4f, 0xfd, 0x37, 0x05, 0x4e, 0x73, 0x79, 0x39, 0xf0, 0xb8, + 0x8c, 0x49, 0xab, 0xe4, 0x4c, 0xda, 0x8e, 0x87, 0x4d, 0x6c, 0x07, 0x96, 0xd1, 0xa3, 0xfe, 0x98, + 0x38, 0x10, 0x8f, 0x92, 0xa9, 0x4b, 0x78, 0x0e, 0x66, 0x19, 0x3c, 0x96, 0x07, 0xd2, 0x0c, 0x05, + 0x3b, 0x43, 0x11, 0xb2, 0x3c, 0x56, 0xde, 0xce, 0x32, 0x94, 0xa5, 0xdc, 0x1d, 0x98, 0x91, 0xf6, + 0x52, 0x75, 0x60, 0x39, 0x07, 0x9a, 0x90, 0x39, 0x22, 0x94, 0xf4, 0x88, 0x18, 0xaa, 0xa4, 0xf4, + 0x88, 0xf8, 0x8e, 0x02, 0x67, 0x52, 0x01, 0xfd, 0xe7, 0xaf, 0x59, 0xf5, 0x4f, 0x94, 0x70, 0xfc, + 0x24, 0x67, 0xd7, 0x5a, 0x7a, 0x76, 0xbd, 0x30, 0x6c, 0x7f, 0x22, 0x73, 0x7e, 0x7d, 0x90, 0x3b, + 0xbf, 0x5e, 0x1e, 0xba, 0xd7, 0x31, 0x4a, 0x9f, 0xff, 0xac, 0xc0, 0x89, 0xdc, 0x0a, 0x24, 0xdc, + 0x5b, 0x25, 0xe9, 0xde, 0x72, 0xd7, 0x38, 0x0a, 0x66, 0x98, 0x6b, 0x4c, 0xe3, 0x15, 0xee, 0x83, + 0xea, 0x7d, 0xe3, 0xa9, 0xd5, 0x1f, 0xf4, 0xb9, 0x6f, 0x4c, 0xc4, 0x6d, 0xb2, 0x94, 0xa3, 0x38, + 0xc7, 0x57, 0x60, 0x91, 0xad, 0x5b, 0xd4, 0x3f, 0x8b, 0x38, 0x98, 0x8f, 0xbc, 0xc0, 0xf2, 0x88, + 0xab, 0xc6, 0x19, 0xd4, 0x06, 0x2c, 0x84, 0xcd, 0x1a, 0x0a, 0xcd, 0x8a, 0x41, 0xad, 0x0a, 0x32, + 0xd4, 0xca, 0x86, 0xa9, 0x75, 0xfc, 0xd8, 0xea, 0xe0, 0x67, 0x02, 0x53, 0x3f, 0x0b, 0x33, 0x2e, + 0xf6, 0xfa, 0x96, 0xef, 0x87, 0x4e, 0x4a, 0x45, 0x8b, 0x27, 0xa9, 0x67, 0xa0, 0xb2, 0xb6, 0xde, + 0xe4, 0x45, 0x66, 0x54, 0x55, 0xfd, 0xf7, 0x29, 0x98, 0x4f, 0x8e, 0xb1, 0x9b, 0x29, 0xe8, 0xd7, + 0xe9, 0xcc, 0x6d, 0xc3, 0x8c, 0xfd, 0xf2, 0x10, 0x11, 0x5e, 0x18, 0x8d, 0x08, 0x27, 0x6a, 0xea, + 0x38, 0xfd, 0xbe, 0x61, 0x9b, 0xe2, 0xb2, 0x01, 0xff, 0x24, 0x35, 0x35, 0xbc, 0x2e, 0xdb, 0x29, + 0xaf, 0x68, 0xf4, 0x37, 0x19, 0x02, 0xc4, 0x18, 0x5a, 0x36, 0x05, 0x8f, 0xd1, 0x5e, 0xaa, 0x68, + 0xc0, 0x93, 0xd6, 0x2d, 0x0f, 0x9d, 0x87, 0x12, 0xb6, 0x1f, 0x8b, 0x23, 0x34, 0x69, 0xc7, 0x56, + 0x84, 0x78, 0x1a, 0xa5, 0x40, 0x17, 0x60, 0xaa, 0x4f, 0x86, 0x95, 0x00, 0x18, 0x2c, 0xa4, 0x40, + 0xf9, 0x1a, 0x27, 0x40, 0xaf, 0xc0, 0xb4, 0x49, 0xb5, 0x27, 0x62, 0x1a, 0x24, 0xc1, 0xd0, 0x68, + 0x96, 0x26, 0x48, 0xd0, 0xbb, 0xe1, 0x71, 0x41, 0x25, 0x7d, 0x8e, 0x97, 0x50, 0x73, 0xe6, 0x49, + 0xc1, 0x96, 0x1c, 0x73, 0x43, 0xfa, 0xd0, 0x21, 0x29, 0x65, 0x78, 0xe4, 0x7d, 0x02, 0xca, 0x3d, + 0xa7, 0xcb, 0x46, 0xcf, 0x0c, 0xbb, 0xa9, 0xd2, 0x73, 0xba, 0x74, 0xf0, 0x2c, 0xc2, 0xa4, 0x1f, + 0x98, 0x96, 0x4d, 0x5d, 0xc3, 0xb2, 0xc6, 0x3e, 0xc8, 0x24, 0xa5, 0x3f, 0x74, 0xc7, 0xee, 0xe0, + 0x95, 0x2a, 0xcd, 0xaa, 0xd0, 0x94, 0x6d, 0xbb, 0x43, 0x43, 0xe4, 0x20, 0x38, 0x58, 0x99, 0xa3, + 0xe9, 0xe4, 0x67, 0xb4, 0x6b, 0x3f, 0x9f, 0xb3, 0x6b, 0x9f, 0xa8, 0x70, 0xc6, 0xae, 0x7d, 0x2d, + 0x77, 0xcd, 0x48, 0xf2, 0x0a, 0x16, 0xe2, 0x16, 0xaf, 0xad, 0x37, 0x75, 0xd1, 0x35, 0x0b, 0x69, + 0x18, 0x7e, 0x38, 0xec, 0x35, 0x08, 0x7f, 0x7e, 0xae, 0x87, 0x26, 0x3f, 0x52, 0x60, 0x69, 0x8d, + 0x1e, 0x19, 0xc7, 0x6c, 0xe3, 0x61, 0xd0, 0x56, 0xaf, 0x85, 0x10, 0xb8, 0x0c, 0x1c, 0x53, 0x52, + 0x53, 0x02, 0x01, 0xb7, 0x06, 0x73, 0x42, 0x2c, 0x67, 0x2e, 0x8e, 0x81, 0x9f, 0xab, 0xfa, 0xf1, + 0x4f, 0xf5, 0x36, 0x2c, 0xa7, 0x6a, 0xce, 0x0f, 0xee, 0x92, 0xf7, 0x35, 0x58, 0xc5, 0xe3, 0xf7, + 0x35, 0xd4, 0x5b, 0x70, 0xbc, 0x1d, 0x18, 0x5e, 0x90, 0x6a, 0xf6, 0x18, 0xbc, 0x14, 0x19, 0x27, + 0xf3, 0x72, 0xf0, 0x5a, 0x1b, 0x16, 0xdb, 0x81, 0xe3, 0x1e, 0x41, 0x28, 0xb1, 0x3b, 0xa4, 0xe5, + 0xce, 0x40, 0xac, 0x33, 0xe2, 0x53, 0x5d, 0x66, 0x38, 0xbe, 0x74, 0x69, 0x6f, 0xc1, 0x12, 0x83, + 0xd1, 0x1d, 0xa5, 0x11, 0x27, 0x04, 0x88, 0x2f, 0x2d, 0xf7, 0x3e, 0x1c, 0x93, 0x8e, 0x12, 0x38, + 0xec, 0xe4, 0xaa, 0x0c, 0x3b, 0xc9, 0x3f, 0xb5, 0x09, 0x51, 0x27, 0xbf, 0x59, 0x88, 0xd9, 0xf1, + 0x9c, 0xb3, 0xe7, 0xd7, 0x65, 0xd0, 0xc9, 0x99, 0x7c, 0xa9, 0x12, 0xe6, 0x24, 0x3d, 0x3a, 0x8b, + 0x19, 0xa3, 0x73, 0x37, 0x75, 0xb0, 0x5d, 0x4a, 0x83, 0x86, 0x12, 0x35, 0xfc, 0x4c, 0x8e, 0xb4, + 0x1f, 0x30, 0x60, 0x4a, 0x58, 0x74, 0x78, 0x9a, 0xfd, 0x5a, 0xe2, 0x34, 0xfb, 0xe4, 0x90, 0x9a, + 0x86, 0xe7, 0xd8, 0x3f, 0x28, 0x41, 0x25, 0xcc, 0x4b, 0x69, 0x38, 0xad, 0xaa, 0x42, 0x86, 0xaa, + 0xe2, 0xeb, 0x6b, 0xf1, 0x88, 0xeb, 0x6b, 0x69, 0x8c, 0xf5, 0xf5, 0x24, 0x54, 0xe8, 0x0f, 0x7a, + 0x97, 0x80, 0xad, 0x97, 0x65, 0x9a, 0xa0, 0xe1, 0xbd, 0x68, 0x88, 0x4d, 0x8d, 0x39, 0xc4, 0x12, + 0x20, 0x98, 0xe9, 0x24, 0x08, 0xe6, 0x66, 0xb8, 0xf6, 0x95, 0xd3, 0x87, 0x4e, 0xa1, 0xc4, 0xcc, + 0x55, 0x2f, 0xb1, 0xd3, 0x5c, 0x49, 0xef, 0x34, 0x47, 0xfc, 0x23, 0xd7, 0x3b, 0xd6, 0x64, 0xcb, + 0x64, 0xf1, 0xab, 0x36, 0x4d, 0xbf, 0x9b, 0xe6, 0xe7, 0x69, 0xfa, 0xb7, 0x19, 0xe8, 0x25, 0x3e, + 0x04, 0xb9, 0xf9, 0x7c, 0x5d, 0x3a, 0x6f, 0x54, 0x32, 0x96, 0xb1, 0xd0, 0x64, 0xc4, 0xcf, 0x18, + 0x77, 0x61, 0x29, 0x09, 0x96, 0x3b, 0x94, 0xf9, 0xcb, 0x41, 0xed, 0xfe, 0x2c, 0xee, 0x0c, 0xe6, + 0x40, 0x54, 0x6f, 0xa6, 0xd0, 0x14, 0x63, 0x0f, 0xde, 0xab, 0x32, 0xf0, 0xea, 0xd0, 0x43, 0x2e, + 0x85, 0xbb, 0xa2, 0xce, 0x8a, 0xe1, 0xf1, 0x6c, 0xe6, 0xb7, 0x57, 0x78, 0x4a, 0x83, 0x06, 0x0d, + 0x7b, 0x96, 0x6d, 0xf9, 0xfb, 0x2c, 0x7f, 0x8a, 0x05, 0x0d, 0x22, 0xa9, 0x41, 0xf7, 0x67, 0xf1, + 0x53, 0x2b, 0xd0, 0x3b, 0x8e, 0x89, 0xe9, 0x80, 0x9e, 0xd4, 0xca, 0x24, 0x61, 0xcd, 0x31, 0x71, + 0x34, 0xd5, 0xca, 0x87, 0x9d, 0x6a, 0x95, 0xc4, 0x54, 0x5b, 0x82, 0x29, 0x0f, 0x1b, 0xbe, 0x63, + 0xf3, 0x21, 0xc9, 0xbf, 0x48, 0x47, 0xf4, 0xb1, 0xef, 0x93, 0x32, 0xb8, 0x6f, 0xc6, 0x3f, 0x63, + 0x7e, 0xe4, 0xec, 0x10, 0x3f, 0x72, 0x08, 0x00, 0x36, 0xe1, 0x47, 0x56, 0x87, 0xf8, 0x91, 0x63, + 0xe1, 0x5f, 0x23, 0x8f, 0x79, 0x6e, 0x94, 0xc7, 0x1c, 0x77, 0x39, 0xe7, 0x65, 0x97, 0xf3, 0x76, + 0x3c, 0x78, 0xad, 0xa5, 0xe1, 0x00, 0xc3, 0xa3, 0xd6, 0xf8, 0xdc, 0x5e, 0x90, 0xe6, 0x36, 0xba, + 0xc4, 0x37, 0xc9, 0x51, 0x7a, 0x7b, 0x55, 0xda, 0xed, 0x61, 0xfb, 0xe7, 0x9f, 0xa7, 0x29, 0xf8, + 0x3b, 0x05, 0x96, 0x53, 0x53, 0x97, 0x1b, 0x83, 0xd7, 0x12, 0x18, 0xdd, 0xa1, 0xe0, 0x58, 0x01, + 0xd1, 0x6d, 0x48, 0x10, 0xdd, 0x4b, 0xc3, 0x58, 0x72, 0x10, 0xba, 0x47, 0x47, 0xcd, 0x7e, 0x5b, + 0x01, 0x94, 0x11, 0xe8, 0xdf, 0x14, 0x21, 0xc1, 0x21, 0x76, 0xff, 0x78, 0x54, 0xf0, 0x6e, 0x14, + 0x15, 0x14, 0x0e, 0xb3, 0xb9, 0x11, 0xc2, 0x79, 0x36, 0xa0, 0x2a, 0xef, 0xef, 0x5d, 0x97, 0x2b, + 0xb3, 0x9a, 0x5f, 0x19, 0x3a, 0x40, 0x18, 0xb1, 0xfa, 0xb3, 0x02, 0x9c, 0xd9, 0x75, 0xcd, 0x84, + 0xcb, 0xcb, 0x0b, 0x1b, 0xdf, 0xd4, 0xde, 0x94, 0x21, 0x4d, 0x47, 0xd4, 0x44, 0xf1, 0x28, 0x9a, + 0x40, 0x5f, 0xcf, 0x02, 0x9d, 0xdd, 0x96, 0x8e, 0x87, 0x87, 0x37, 0x70, 0x04, 0xfe, 0xec, 0xd3, + 0xce, 0x04, 0x15, 0xce, 0xe6, 0x57, 0x80, 0xbb, 0xc7, 0xff, 0x1b, 0xe6, 0x37, 0x9e, 0xe2, 0x4e, + 0xfb, 0xc0, 0xee, 0x1c, 0x42, 0xeb, 0x35, 0x28, 0x76, 0xfa, 0x26, 0x3f, 0x98, 0x22, 0x3f, 0xe3, + 0x1e, 0x7f, 0x51, 0xf6, 0xf8, 0x75, 0xa8, 0x45, 0x25, 0xf0, 0x79, 0xb8, 0x44, 0xe6, 0xa1, 0x49, + 0x88, 0x89, 0xf0, 0x59, 0x8d, 0x7f, 0xf1, 0x74, 0xec, 0xb1, 0x4b, 0x44, 0x2c, 0x1d, 0x7b, 0x9e, + 0xbc, 0x8c, 0x14, 0xe5, 0x65, 0x44, 0xfd, 0xae, 0x02, 0x33, 0xa4, 0x84, 0x4f, 0x55, 0x7f, 0x1e, + 0x76, 0x17, 0xa3, 0xb0, 0x3b, 0x8c, 0xde, 0x4b, 0xf1, 0xe8, 0x3d, 0xaa, 0xf9, 0x24, 0x4d, 0x4e, + 0xd7, 0x7c, 0x2a, 0x4c, 0xc7, 0x9e, 0xa7, 0x9e, 0x85, 0x59, 0x56, 0x37, 0xde, 0xf2, 0x1a, 0x14, + 0x07, 0x5e, 0x4f, 0xf4, 0xdf, 0xc0, 0xeb, 0xa9, 0xdf, 0x52, 0xa0, 0xda, 0x08, 0x02, 0xa3, 0xb3, + 0x7f, 0x88, 0x06, 0x84, 0x95, 0x2b, 0xc4, 0x2b, 0x97, 0x6e, 0x44, 0x54, 0xdd, 0x52, 0x4e, 0x75, + 0x27, 0xa5, 0xea, 0xaa, 0x30, 0x27, 0xea, 0x92, 0x5b, 0xe1, 0x2d, 0x40, 0x2d, 0xc7, 0x0b, 0xee, + 0x39, 0xde, 0x13, 0xc3, 0x33, 0x0f, 0x17, 0x61, 0x23, 0x28, 0xf1, 0x77, 0x29, 0x8a, 0xe7, 0x27, + 0x35, 0xfa, 0x5b, 0x7d, 0x09, 0x8e, 0x49, 0xf2, 0x72, 0x0b, 0xbe, 0x05, 0x33, 0xd4, 0x2d, 0xe0, + 0xc1, 0xd7, 0xcb, 0x71, 0x4c, 0xc5, 0xa8, 0xb7, 0x11, 0xd6, 0x61, 0x81, 0x38, 0x88, 0x34, 0x3d, + 0xb4, 0x2f, 0x57, 0x12, 0xf1, 0xc9, 0x72, 0x4a, 0x44, 0x22, 0x36, 0xf9, 0x85, 0x02, 0x93, 0x0c, + 0x3e, 0x91, 0x74, 0xda, 0x4e, 0x92, 0x85, 0xd7, 0x75, 0xf4, 0xc0, 0xe8, 0x86, 0x6f, 0x7e, 0x90, + 0x84, 0x1d, 0xa3, 0x4b, 0x0f, 0xba, 0x68, 0xa6, 0x69, 0x75, 0xb1, 0x1f, 0x88, 0xc3, 0xd9, 0x19, + 0x92, 0xb6, 0xce, 0x92, 0x88, 0x62, 0xe8, 0x19, 0x76, 0x89, 0x1e, 0x55, 0xd3, 0xdf, 0xe8, 0x3c, + 0x3b, 0x38, 0x19, 0x7e, 0x22, 0x49, 0x0f, 0x54, 0xea, 0x50, 0x4e, 0x1c, 0x25, 0x86, 0xdf, 0xe8, + 0x02, 0x94, 0xe8, 0x5e, 0xf9, 0xf4, 0x30, 0x2d, 0x51, 0x12, 0x32, 0x2a, 0x5c, 0xcb, 0xb6, 0xb1, + 0xc9, 0x1f, 0xa4, 0xe0, 0x5f, 0xea, 0xbb, 0x80, 0xe2, 0xca, 0xe3, 0x1d, 0x74, 0x01, 0xa6, 0xa8, + 0x6e, 0x85, 0x57, 0xbd, 0x90, 0x12, 0xad, 0x71, 0x02, 0xf5, 0x6b, 0x80, 0x58, 0x59, 0x92, 0x27, + 0x7d, 0x98, 0x0e, 0x1c, 0xe2, 0x53, 0xff, 0x50, 0x81, 0x63, 0x92, 0x74, 0x5e, 0xbf, 0x97, 0x64, + 0xf1, 0x19, 0xd5, 0xe3, 0xa2, 0xdf, 0x96, 0x16, 0xf8, 0x0b, 0xe9, 0x6a, 0xfc, 0x0f, 0x2d, 0xee, + 0x7f, 0xaf, 0x00, 0x34, 0x06, 0xc1, 0x3e, 0xdf, 0x14, 0x8e, 0x77, 0xa2, 0x92, 0xe8, 0xc4, 0x3a, + 0x94, 0x5d, 0xc3, 0xf7, 0x9f, 0x38, 0x9e, 0x08, 0x78, 0xc3, 0x6f, 0xba, 0x95, 0x3b, 0xe0, 0x6f, + 0x75, 0x54, 0x34, 0xfa, 0x1b, 0xbd, 0x00, 0x73, 0xec, 0x31, 0x1a, 0xdd, 0x30, 0x4d, 0x4f, 0xe0, + 0x34, 0x2b, 0x5a, 0x95, 0xa5, 0x36, 0x58, 0x22, 0x21, 0xb3, 0xe8, 0xc9, 0x49, 0x70, 0xa0, 0x07, + 0xce, 0x23, 0x6c, 0xf3, 0x20, 0xb6, 0x2a, 0x52, 0x77, 0x48, 0x22, 0x3b, 0x85, 0xed, 0x5a, 0x7e, + 0xe0, 0x09, 0x32, 0x71, 0x5e, 0xcd, 0x53, 0x29, 0x99, 0xfa, 0x47, 0x0a, 0xd4, 0x5a, 0x83, 0x5e, + 0x8f, 0x29, 0xf7, 0x28, 0x9d, 0x7c, 0x91, 0x37, 0xa5, 0x90, 0x1e, 0xf2, 0x91, 0xa2, 0x78, 0x13, + 0x9f, 0xc9, 0xbe, 0xdb, 0x55, 0x58, 0x88, 0xd5, 0x98, 0x0f, 0x1c, 0x29, 0xd4, 0x50, 0xe4, 0x50, + 0x43, 0x6d, 0x00, 0x62, 0x5b, 0x4d, 0x47, 0x6e, 0xa5, 0x7a, 0x1c, 0x8e, 0x49, 0x22, 0xf8, 0x52, + 0x7c, 0x11, 0xaa, 0x1c, 0x33, 0xc8, 0x07, 0xc4, 0x09, 0x28, 0x13, 0x93, 0xda, 0xb1, 0x4c, 0x01, + 0x4e, 0x99, 0x76, 0x1d, 0x73, 0xcd, 0x32, 0x3d, 0xf5, 0xcb, 0x50, 0xe5, 0x8f, 0x12, 0x70, 0xda, + 0x3b, 0x30, 0xc7, 0xcf, 0x32, 0x75, 0xe9, 0x16, 0xef, 0x89, 0x0c, 0x60, 0xaa, 0x50, 0x85, 0x1d, + 0xff, 0x54, 0xbf, 0x0e, 0x75, 0xe6, 0x2d, 0x48, 0x82, 0x45, 0x03, 0xef, 0x80, 0xc0, 0x85, 0x0d, + 0x91, 0x2f, 0x73, 0x56, 0xbd, 0xf8, 0xa7, 0x7a, 0x1a, 0x4e, 0x66, 0xca, 0xe7, 0xad, 0x77, 0xa1, + 0x16, 0x65, 0xb0, 0xab, 0xa6, 0x21, 0xe2, 0x46, 0x89, 0x21, 0x6e, 0x96, 0x42, 0x17, 0xbe, 0x20, + 0x56, 0x2e, 0xea, 0xa5, 0x47, 0x21, 0x60, 0x31, 0x2f, 0x04, 0x2c, 0x49, 0x21, 0xa0, 0xba, 0x19, + 0xea, 0x90, 0x07, 0xe2, 0xb7, 0xe9, 0x56, 0x01, 0x2b, 0x5b, 0x18, 0xb5, 0x53, 0xd9, 0xed, 0x63, + 0x44, 0x5a, 0x8c, 0x5e, 0xbd, 0x00, 0x55, 0xd9, 0xbc, 0xc5, 0x2c, 0x96, 0x22, 0x5b, 0xac, 0xff, + 0x03, 0x4b, 0x9a, 0x04, 0xb2, 0xbb, 0x87, 0x8d, 0x60, 0xe0, 0x61, 0x1f, 0xbd, 0x05, 0xf5, 0x8c, + 0xf7, 0x81, 0x74, 0x1e, 0x19, 0x32, 0x31, 0xcb, 0xa9, 0x67, 0x82, 0x36, 0x59, 0x5c, 0xf8, 0x12, + 0xcc, 0x53, 0x10, 0x60, 0xec, 0xf2, 0x2c, 0xd3, 0x11, 0x7d, 0x5e, 0x66, 0x2b, 0xba, 0x29, 0x6b, + 0x86, 0x4f, 0x5a, 0xf0, 0xf2, 0x33, 0xcf, 0xd8, 0xde, 0x81, 0xf2, 0x1e, 0xaf, 0x17, 0x9f, 0x90, + 0x6a, 0x86, 0x32, 0x12, 0x2d, 0xd0, 0x42, 0x1e, 0x75, 0x1b, 0xe6, 0x39, 0x4d, 0xd8, 0xbc, 0xdb, + 0x43, 0x71, 0x27, 0xac, 0x79, 0xb9, 0x88, 0x12, 0xf5, 0x87, 0x05, 0x98, 0x4b, 0xd8, 0xf8, 0x57, + 0x13, 0x01, 0x5d, 0xd6, 0x70, 0x4c, 0x84, 0x73, 0x37, 0x24, 0x6b, 0x2f, 0xa3, 0x5c, 0x86, 0xdf, + 0xb3, 0xdc, 0x80, 0x5a, 0x02, 0x32, 0x29, 0xe0, 0xd2, 0xf5, 0x7c, 0xc5, 0x68, 0xf3, 0x32, 0x9e, + 0xd2, 0x47, 0x6f, 0xc6, 0xf4, 0x5a, 0x4a, 0x87, 0xa1, 0x09, 0x9d, 0x45, 0x0a, 0x3d, 0xfa, 0x42, + 0xb3, 0xc8, 0x97, 0xdf, 0x7b, 0x3e, 0xe1, 0xe7, 0xe3, 0x53, 0x7d, 0x0e, 0x66, 0x76, 0xf3, 0x5e, + 0x0d, 0x2a, 0x09, 0x24, 0xe6, 0x1b, 0xb0, 0x78, 0xcf, 0xea, 0x61, 0xff, 0xc0, 0x0f, 0x70, 0xbf, + 0x49, 0x57, 0x85, 0x3d, 0x0b, 0x7b, 0x68, 0x15, 0x80, 0x0e, 0x4a, 0xd7, 0xb1, 0xc2, 0x57, 0x4c, + 0x62, 0x29, 0xea, 0x4f, 0x15, 0x98, 0x8f, 0x18, 0xc7, 0x81, 0xdb, 0xbe, 0x0e, 0x93, 0x7b, 0xbe, + 0xd8, 0xd0, 0x4d, 0x1c, 0x73, 0x65, 0x55, 0x41, 0x2b, 0xed, 0xf9, 0x4d, 0x13, 0xbd, 0x01, 0x30, + 0xf0, 0xb1, 0xc9, 0x4f, 0x96, 0x47, 0x00, 0xa0, 0x2b, 0x84, 0x94, 0x9d, 0x4d, 0xdf, 0x80, 0x19, + 0xcb, 0x76, 0x4c, 0x4c, 0x51, 0x07, 0xe6, 0x28, 0xf0, 0x33, 0x30, 0xda, 0x5d, 0x1f, 0x9b, 0xea, + 0xef, 0x45, 0xd8, 0x81, 0x2f, 0x72, 0x0b, 0xd5, 0x3f, 0x16, 0x7e, 0x91, 0xe8, 0x76, 0x3e, 0x67, + 0xde, 0x83, 0x05, 0xb6, 0xbc, 0xed, 0x85, 0x65, 0x66, 0xde, 0x0a, 0x4b, 0x34, 0x4e, 0xab, 0x59, + 0xdc, 0x23, 0x16, 0x4c, 0xa8, 0x05, 0xc7, 0xa3, 0x40, 0x25, 0x2e, 0xad, 0x30, 0x5a, 0xda, 0x62, + 0x27, 0xb6, 0xff, 0x2f, 0x18, 0xd5, 0x5b, 0x70, 0x3c, 0x71, 0xf1, 0x63, 0xfc, 0x43, 0xa0, 0xf7, + 0x13, 0x5b, 0xb6, 0x91, 0x95, 0xb8, 0x2a, 0xdf, 0x37, 0x1c, 0x76, 0x45, 0x87, 0x5f, 0x7d, 0xdb, + 0x85, 0x13, 0xd2, 0x7e, 0xb2, 0x54, 0x97, 0x1b, 0x89, 0xb0, 0xe1, 0x6c, 0xbe, 0xbc, 0x44, 0xfc, + 0xf0, 0x1f, 0x0a, 0x2c, 0x66, 0x11, 0x1c, 0xf1, 0x98, 0xe3, 0xa3, 0x9c, 0xbb, 0xca, 0xaf, 0x8d, + 0xaa, 0xd0, 0x67, 0x72, 0x2c, 0xb4, 0xc5, 0x6e, 0x3a, 0x8e, 0xee, 0x93, 0xe2, 0x78, 0x7d, 0xf2, + 0x8b, 0x42, 0xec, 0x28, 0x6f, 0xc8, 0x6d, 0xc4, 0x4f, 0xb1, 0x7f, 0xbe, 0x96, 0xb8, 0x8c, 0xf8, + 0x72, 0x26, 0xe3, 0x88, 0xbb, 0x88, 0x5a, 0xd6, 0xb6, 0xd0, 0xd5, 0x51, 0x92, 0xbe, 0xb0, 0x57, + 0x11, 0x7f, 0xab, 0x00, 0x73, 0x72, 0x87, 0xa0, 0x77, 0x33, 0x6e, 0x22, 0x9e, 0x19, 0xd1, 0x40, + 0xe9, 0x22, 0x22, 0xbf, 0xf9, 0x57, 0x18, 0xff, 0xe6, 0x5f, 0x71, 0xbc, 0x9b, 0x7f, 0x77, 0x61, + 0xee, 0x89, 0x67, 0x05, 0xc6, 0xc3, 0x1e, 0xd6, 0x7b, 0xc6, 0x01, 0xf6, 0xb2, 0x56, 0xd8, 0xa4, + 0x29, 0xaa, 0x0a, 0x96, 0x07, 0x84, 0x83, 0x06, 0xcc, 0x4f, 0x0c, 0x97, 0xc7, 0xdd, 0x92, 0x2b, + 0xdf, 0x7e, 0x62, 0xb8, 0x8c, 0x87, 0x92, 0xa8, 0xdf, 0x2a, 0xc0, 0xf1, 0xcc, 0xfb, 0x6a, 0x9f, + 0x5e, 0x45, 0x97, 0xe2, 0x2a, 0x3a, 0xcc, 0x25, 0xc0, 0xe2, 0xa1, 0x2e, 0x01, 0x36, 0x73, 0x14, + 0x96, 0x85, 0x15, 0x19, 0xae, 0x37, 0xf5, 0xcf, 0x15, 0x28, 0x8b, 0x4a, 0x8d, 0xbc, 0x92, 0xb7, + 0x3c, 0x20, 0x64, 0x3a, 0xbd, 0x36, 0x61, 0x1b, 0xb6, 0xa3, 0xfb, 0x98, 0xf8, 0xd2, 0x23, 0x2f, + 0x40, 0x2d, 0x52, 0xbe, 0x35, 0xc7, 0xc3, 0x5b, 0x86, 0xed, 0xb4, 0x19, 0x13, 0x6a, 0x40, 0x8d, + 0xc9, 0xa3, 0xa2, 0x88, 0xd0, 0x91, 0x0b, 0xe5, 0x1c, 0x65, 0x20, 0x42, 0x88, 0x30, 0x5f, 0xfd, + 0x2b, 0x05, 0xe6, 0x13, 0x9a, 0xfd, 0xd5, 0x6b, 0xc4, 0xf7, 0x8b, 0x30, 0x13, 0xeb, 0xe5, 0x11, + 0x0d, 0x58, 0x83, 0x05, 0x81, 0xf7, 0xf2, 0x71, 0x30, 0xde, 0x05, 0xb4, 0x79, 0xce, 0xd1, 0xc6, + 0x01, 0xf3, 0xa3, 0xee, 0xc0, 0xbc, 0xf1, 0xd8, 0xb0, 0x7a, 0x74, 0x04, 0x8d, 0xe5, 0xa2, 0xcc, + 0x85, 0xf4, 0xa1, 0x27, 0xc6, 0xda, 0x3d, 0xd6, 0x35, 0x34, 0xa0, 0xb4, 0xd1, 0x6d, 0x40, 0xdf, + 0x8f, 0x81, 0x0a, 0x87, 0xde, 0x06, 0xf4, 0xfd, 0xb0, 0x3c, 0x7a, 0x67, 0x84, 0x5e, 0x83, 0xf4, + 0xf9, 0xdb, 0x39, 0xf9, 0xe5, 0x11, 0xda, 0x7b, 0x94, 0x94, 0x28, 0xac, 0x6f, 0x7c, 0xec, 0x78, + 0x7a, 0x9c, 0x7f, 0x7a, 0x84, 0xc2, 0x28, 0x47, 0x2b, 0x14, 0xa2, 0xfe, 0xa9, 0x02, 0x95, 0xd0, + 0x8e, 0x8c, 0xe8, 0xa1, 0x26, 0x2c, 0xd2, 0x0b, 0x36, 0x49, 0x0d, 0x8f, 0xe8, 0x24, 0x44, 0x98, + 0x1a, 0xb2, 0x96, 0x1b, 0x50, 0xa3, 0xa2, 0xe2, 0xaa, 0x1e, 0xd5, 0x51, 0xbe, 0xa8, 0x26, 0x73, + 0x28, 0xff, 0xa2, 0x00, 0x28, 0x6d, 0x4a, 0x7e, 0x65, 0x06, 0x59, 0xbc, 0xd3, 0x4a, 0xe3, 0x77, + 0xfa, 0x7d, 0x38, 0xd6, 0x71, 0xfa, 0x7d, 0x8b, 0x5e, 0xce, 0x72, 0xbc, 0x83, 0xf1, 0x86, 0xdb, + 0x02, 0xe3, 0x61, 0x7a, 0x62, 0xea, 0x7b, 0x07, 0x4e, 0x68, 0xd8, 0x71, 0xb1, 0x1d, 0x9a, 0xfe, + 0x07, 0x4e, 0xf7, 0x10, 0xfe, 0xed, 0x29, 0xa8, 0x67, 0xf1, 0xf3, 0xfd, 0x93, 0x01, 0xd4, 0xd7, + 0xf6, 0x71, 0xe7, 0x11, 0x0d, 0xbf, 0x8e, 0x82, 0xd9, 0xaa, 0x43, 0xb9, 0xe7, 0x74, 0xd8, 0x4b, + 0xca, 0x7c, 0x8b, 0x51, 0x7c, 0x0f, 0x39, 0xdd, 0x39, 0x0d, 0x27, 0x33, 0x8b, 0xe5, 0xb5, 0x42, + 0x50, 0xbb, 0x8f, 0x83, 0x8d, 0xc7, 0xd8, 0x0e, 0xdd, 0x67, 0xf5, 0xc7, 0x85, 0x98, 0xa3, 0x4e, + 0xb3, 0x0e, 0x81, 0x75, 0x43, 0x2d, 0x88, 0x22, 0x07, 0x1d, 0x13, 0x6e, 0xf6, 0x2c, 0x28, 0x7b, + 0xb4, 0x37, 0xfb, 0xb0, 0x9b, 0x16, 0x42, 0x5f, 0x03, 0x8d, 0x1e, 0x3c, 0x0a, 0xd3, 0x12, 0x10, + 0x88, 0x62, 0x12, 0x02, 0xf1, 0x3e, 0xa0, 0xb8, 0x2b, 0xce, 0xb7, 0x1b, 0x4a, 0x63, 0xbc, 0xf1, + 0x54, 0x73, 0x93, 0xaf, 0x91, 0xe5, 0xbc, 0xd4, 0x34, 0x79, 0xa4, 0x97, 0x9a, 0xd4, 0x55, 0x38, + 0x45, 0x1c, 0xec, 0x4d, 0x1c, 0x78, 0x56, 0x67, 0x1d, 0xfb, 0x1d, 0xcf, 0x72, 0x03, 0x27, 0x84, + 0x5f, 0xa9, 0x3a, 0x9c, 0xce, 0xc9, 0xe7, 0xea, 0x7e, 0x07, 0x66, 0xcc, 0x28, 0x39, 0x6b, 0xc7, + 0x2b, 0xc9, 0xab, 0xc5, 0x19, 0xd4, 0x0f, 0xa1, 0x96, 0x24, 0xc8, 0xdc, 0x49, 0x42, 0x50, 0xda, + 0xc7, 0x3d, 0x57, 0xdc, 0xa6, 0x23, 0xbf, 0x89, 0xd6, 0x59, 0xec, 0xf2, 0x08, 0x1f, 0x88, 0x13, + 0x91, 0x0a, 0x4d, 0xf9, 0x12, 0x3e, 0x08, 0xdb, 0x26, 0x3d, 0x1d, 0xe2, 0x59, 0x9d, 0x64, 0xdb, + 0x32, 0xf2, 0xa3, 0xb6, 0x91, 0x6e, 0xeb, 0xb3, 0x64, 0xde, 0xb6, 0xd3, 0xb9, 0xcf, 0x92, 0x50, + 0x5e, 0x70, 0x1d, 0x93, 0xff, 0x56, 0x7f, 0xa0, 0xc0, 0x42, 0x8a, 0x62, 0xcc, 0x53, 0xae, 0x57, + 0x60, 0x5a, 0x94, 0x5b, 0x48, 0x43, 0x9a, 0x99, 0x2c, 0x4d, 0x90, 0xa0, 0x26, 0x2c, 0x44, 0x23, + 0x5a, 0xf0, 0x15, 0xd3, 0x7d, 0x11, 0x0f, 0x5c, 0x68, 0x75, 0x6b, 0x9d, 0x44, 0x8a, 0xda, 0x81, + 0x5a, 0x92, 0x6a, 0x9c, 0x39, 0x75, 0xa8, 0xfa, 0xaa, 0x7f, 0xa3, 0xc0, 0x14, 0x4b, 0xcb, 0xec, + 0x6c, 0x69, 0x39, 0x28, 0x24, 0x97, 0x83, 0x37, 0x61, 0x86, 0xc9, 0xd1, 0xc3, 0xbb, 0x94, 0x73, + 0xf2, 0x46, 0x3f, 0x13, 0x4d, 0x67, 0x2b, 0xf4, 0xc3, 0xdf, 0xa4, 0x19, 0x6c, 0xbc, 0xd0, 0xc8, + 0x44, 0x00, 0xd7, 0x67, 0x68, 0x1a, 0x35, 0xb9, 0xc4, 0x65, 0xe6, 0x31, 0xcc, 0x08, 0xdb, 0xcc, + 0xb7, 0xb6, 0x96, 0xe8, 0x43, 0x98, 0xa9, 0xad, 0x6e, 0x75, 0x87, 0xbe, 0x54, 0x99, 0xde, 0xa2, + 0x46, 0x6f, 0xc9, 0x40, 0x87, 0x17, 0x52, 0x58, 0x03, 0x89, 0x6d, 0xe0, 0xb1, 0x17, 0xe7, 0x39, + 0xde, 0xe1, 0x23, 0x38, 0x91, 0x4b, 0x83, 0xde, 0x0e, 0x9f, 0x05, 0x36, 0x3d, 0xeb, 0x31, 0xdf, + 0x58, 0x98, 0x93, 0x9f, 0x20, 0x59, 0xa3, 0x04, 0xeb, 0x34, 0x5f, 0x3c, 0x18, 0xcc, 0xbe, 0x2e, + 0xbe, 0x08, 0x65, 0xf1, 0xdf, 0x00, 0xd0, 0x34, 0x14, 0x77, 0xd6, 0x5a, 0xb5, 0x09, 0xf2, 0x63, + 0x77, 0xbd, 0x55, 0x53, 0x50, 0x19, 0x4a, 0xed, 0xb5, 0x9d, 0x56, 0xad, 0x70, 0xb1, 0x0f, 0xb5, + 0xe4, 0x83, 0xf8, 0x68, 0x19, 0x8e, 0xb5, 0xb4, 0xed, 0x56, 0xe3, 0x7e, 0x63, 0xa7, 0xb9, 0xbd, + 0xa5, 0xb7, 0xb4, 0xe6, 0x07, 0x8d, 0x9d, 0x8d, 0xda, 0x04, 0x3a, 0x07, 0xa7, 0xe3, 0x19, 0xef, + 0x6d, 0xb7, 0x77, 0xf4, 0x9d, 0x6d, 0x7d, 0x6d, 0x7b, 0x6b, 0xa7, 0xd1, 0xdc, 0xda, 0xd0, 0x6a, + 0x0a, 0x3a, 0x0d, 0x27, 0xe2, 0x24, 0x77, 0x9b, 0xeb, 0x4d, 0x6d, 0x63, 0x8d, 0xfc, 0x6e, 0x3c, + 0xa8, 0x15, 0x2e, 0xbe, 0x0d, 0x55, 0xe9, 0xba, 0x15, 0xa9, 0x52, 0x6b, 0x7b, 0xbd, 0x36, 0x81, + 0xaa, 0x50, 0x89, 0xcb, 0x29, 0x43, 0x69, 0x6b, 0x7b, 0x7d, 0xa3, 0x56, 0x40, 0x00, 0x53, 0x3b, + 0x0d, 0xed, 0xfe, 0xc6, 0x4e, 0xad, 0x78, 0xf1, 0x55, 0x58, 0xc9, 0xbb, 0x76, 0x88, 0x2a, 0x30, + 0xb9, 0x89, 0xbd, 0x2e, 0xae, 0x4d, 0x10, 0x96, 0x36, 0x19, 0x25, 0x41, 0x4d, 0xb9, 0x78, 0x2b, + 0xf9, 0x6a, 0x0e, 0x46, 0x0b, 0x50, 0x6d, 0x37, 0xb6, 0xd6, 0xef, 0x6e, 0x7f, 0x55, 0xd7, 0x36, + 0x1a, 0xeb, 0x1f, 0xd6, 0x26, 0xd0, 0x22, 0xd4, 0x44, 0xd2, 0xd6, 0xf6, 0x0e, 0x4b, 0x55, 0x2e, + 0x3e, 0x4a, 0x84, 0xb9, 0x18, 0x1d, 0x87, 0x85, 0xb0, 0x96, 0xfa, 0x9a, 0xb6, 0xd1, 0xd8, 0xd9, + 0x20, 0x95, 0x97, 0x92, 0xb5, 0xdd, 0xad, 0xad, 0xe6, 0xd6, 0xfd, 0x9a, 0x42, 0xa4, 0x46, 0xc9, + 0x1b, 0x5f, 0x6d, 0x12, 0xe2, 0x82, 0x4c, 0xbc, 0xbb, 0xf5, 0xa5, 0xad, 0xed, 0xaf, 0x6c, 0xd5, + 0x8a, 0x17, 0xff, 0x7f, 0x1c, 0xd7, 0x13, 0x2d, 0x45, 0x27, 0x61, 0x39, 0x55, 0xa2, 0xbe, 0xf1, + 0xc1, 0xc6, 0xd6, 0x4e, 0x6d, 0x42, 0xce, 0x6c, 0xef, 0x34, 0xb4, 0x28, 0x53, 0x49, 0x66, 0x6e, + 0xb7, 0x5a, 0x61, 0x66, 0x41, 0xce, 0x5c, 0xdf, 0x78, 0xb0, 0x11, 0x71, 0x16, 0x2f, 0x3e, 0x0f, + 0x10, 0x4d, 0x39, 0x34, 0x03, 0xd3, 0x6b, 0xdb, 0xbb, 0x5b, 0x3b, 0x1b, 0x5a, 0x6d, 0x82, 0x68, + 0xf9, 0x7e, 0x63, 0xf7, 0xfe, 0x46, 0x4d, 0xb9, 0x78, 0x01, 0x66, 0xe3, 0x03, 0x90, 0xd0, 0xb5, + 0x3f, 0x6c, 0xef, 0x6c, 0x6c, 0x12, 0x8d, 0xcc, 0x42, 0x79, 0xed, 0xbe, 0xb6, 0xbd, 0xdb, 0xba, + 0xd7, 0xae, 0x29, 0xd7, 0xfe, 0x6b, 0x31, 0x3c, 0x5e, 0x68, 0x63, 0x8f, 0xde, 0x8b, 0x59, 0x87, + 0x69, 0xf1, 0x2f, 0x37, 0xa4, 0x8d, 0x1e, 0xf9, 0x5f, 0x84, 0xd4, 0x4f, 0x66, 0xe6, 0x71, 0x57, + 0x62, 0x02, 0x7d, 0x40, 0x0f, 0x6c, 0x62, 0x6f, 0xd6, 0x9d, 0x4d, 0xec, 0x9b, 0xa7, 0x9e, 0xc6, + 0xab, 0x9f, 0x1b, 0x42, 0x11, 0xca, 0xfd, 0x10, 0xe6, 0xe4, 0xc7, 0x61, 0xd1, 0x39, 0xf9, 0x54, + 0x20, 0xe3, 0xdd, 0xd9, 0xba, 0x3a, 0x8c, 0x24, 0x14, 0xad, 0x43, 0x2d, 0xf9, 0x38, 0x2c, 0x92, + 0x30, 0x4a, 0x39, 0x6f, 0xcf, 0xd6, 0x9f, 0x1f, 0x4e, 0x14, 0x2f, 0x20, 0xf5, 0xe6, 0xe9, 0x73, + 0xc3, 0x5f, 0x91, 0xcc, 0x28, 0x20, 0xef, 0xa9, 0x49, 0xa6, 0x1c, 0x79, 0xa1, 0x45, 0x89, 0x67, + 0x46, 0x33, 0x5e, 0x24, 0x94, 0x95, 0x93, 0xfd, 0x1a, 0x9d, 0x3a, 0x81, 0xfe, 0x17, 0xcc, 0x27, + 0x2e, 0x3d, 0x20, 0x89, 0x31, 0xfb, 0x2e, 0x47, 0xfd, 0xb9, 0xa1, 0x34, 0x72, 0xaf, 0xc6, 0x2f, + 0x36, 0x24, 0x7b, 0x35, 0xe3, 0xc2, 0x44, 0xb2, 0x57, 0x33, 0xef, 0x45, 0xd0, 0x81, 0x28, 0x5d, + 0x62, 0x90, 0x07, 0x62, 0xd6, 0xa5, 0x89, 0xfa, 0xb9, 0x21, 0x14, 0x71, 0x85, 0x24, 0xae, 0x31, + 0xc8, 0x0a, 0xc9, 0xbe, 0x20, 0x51, 0x7f, 0x6e, 0x28, 0x4d, 0xb2, 0x27, 0x23, 0x8c, 0x74, 0xba, + 0x27, 0x53, 0x10, 0xfe, 0x74, 0x4f, 0xa6, 0x21, 0xd6, 0xbc, 0x27, 0x13, 0xa8, 0x66, 0x75, 0x28, + 0x4e, 0x32, 0xab, 0x27, 0xb3, 0xb1, 0x94, 0xea, 0x04, 0x7a, 0x02, 0x2b, 0x79, 0x38, 0x36, 0xf4, + 0xf2, 0x21, 0xe0, 0x76, 0xf5, 0x57, 0xc6, 0x23, 0x0e, 0x0b, 0xc6, 0x80, 0xd2, 0x11, 0x17, 0x7a, + 0x41, 0x56, 0x77, 0x4e, 0x44, 0x57, 0x7f, 0x71, 0x14, 0x59, 0x58, 0xcc, 0x7d, 0x28, 0x0b, 0x84, + 0x1c, 0x92, 0x4c, 0x60, 0x02, 0x99, 0x57, 0x3f, 0x95, 0x9d, 0x19, 0x0a, 0x7a, 0x0b, 0x4a, 0x24, + 0x15, 0x2d, 0x27, 0xe9, 0x84, 0x80, 0x95, 0x74, 0x46, 0xc8, 0xdc, 0x80, 0x29, 0x06, 0xfd, 0x42, + 0xd2, 0x21, 0xaa, 0x04, 0x4d, 0xab, 0xd7, 0xb3, 0xb2, 0x42, 0x11, 0x2d, 0xf6, 0x0f, 0x8c, 0x38, + 0x92, 0x0b, 0xad, 0x26, 0x9f, 0x85, 0x97, 0x21, 0x63, 0xf5, 0x33, 0xb9, 0xf9, 0xf1, 0x31, 0x9b, + 0xd8, 0x58, 0x3d, 0x37, 0xe4, 0xa0, 0x20, 0x6b, 0xcc, 0x66, 0x1f, 0x3f, 0xb0, 0xce, 0x4d, 0x1f, + 0x4f, 0xa0, 0x17, 0x72, 0xc7, 0xbb, 0x54, 0xc4, 0x8b, 0xa3, 0xc8, 0xe2, 0x53, 0x23, 0xf9, 0xbe, + 0x9b, 0x3a, 0xec, 0xed, 0xc5, 0xac, 0xa9, 0x91, 0xf3, 0xa6, 0xa3, 0x3a, 0x81, 0xf6, 0xe1, 0x58, + 0xc6, 0xa3, 0x8f, 0xe8, 0xc5, 0x7c, 0xfb, 0x2b, 0x95, 0xf2, 0xd2, 0x48, 0xba, 0x78, 0x49, 0x19, + 0xf0, 0x0d, 0xb9, 0xa4, 0x7c, 0xfc, 0x88, 0x5c, 0xd2, 0x30, 0x1c, 0x08, 0x1d, 0x88, 0xdc, 0x86, + 0x9c, 0xc8, 0x3a, 0x9c, 0xcf, 0x18, 0x88, 0x29, 0x8b, 0xb1, 0x0f, 0xc7, 0x32, 0x76, 0x25, 0xe4, + 0xca, 0xe6, 0xef, 0x96, 0xc8, 0x95, 0x1d, 0xb6, 0xbd, 0x31, 0x81, 0x3e, 0x02, 0x74, 0x1f, 0x07, + 0xb2, 0x2b, 0xe7, 0x23, 0x69, 0xa2, 0x26, 0x37, 0x40, 0x72, 0xc6, 0xa7, 0xb4, 0x13, 0xa2, 0x4e, + 0x5c, 0x55, 0x90, 0xcd, 0xee, 0x55, 0xa5, 0xe2, 0x77, 0x74, 0x3e, 0xd9, 0x6d, 0x79, 0x5b, 0x00, + 0xf5, 0x0b, 0x63, 0x50, 0x86, 0x6d, 0xb1, 0x93, 0x0f, 0x0c, 0x8b, 0x10, 0xf2, 0x7c, 0xfe, 0x30, + 0x91, 0xc3, 0xf2, 0x74, 0x79, 0xb9, 0x01, 0x7a, 0xe8, 0xcf, 0xc5, 0x06, 0xd3, 0xd9, 0x7c, 0x30, + 0x51, 0x8e, 0x3f, 0x97, 0x35, 0x80, 0xae, 0x7d, 0xaf, 0x08, 0xb3, 0x0c, 0x74, 0xc5, 0xdd, 0xcf, + 0x4d, 0x80, 0x08, 0xbf, 0x88, 0x4e, 0x27, 0xeb, 0x28, 0x81, 0x42, 0xeb, 0xab, 0x79, 0xd9, 0x71, + 0x33, 0x17, 0xc3, 0x05, 0xca, 0x66, 0x2e, 0x0d, 0x73, 0x94, 0xcd, 0x5c, 0x06, 0xa0, 0x50, 0x9d, + 0x40, 0xef, 0x43, 0x25, 0x84, 0xa1, 0xc9, 0x83, 0x27, 0x89, 0xa7, 0xab, 0x9f, 0xce, 0xc9, 0x8d, + 0xd7, 0x2e, 0x86, 0x2e, 0x93, 0x6b, 0x97, 0x46, 0xae, 0xc9, 0xb5, 0xcb, 0x82, 0xa5, 0x45, 0xed, + 0x65, 0x38, 0x82, 0x8c, 0xf6, 0x4a, 0xb8, 0x92, 0x8c, 0xf6, 0xca, 0x00, 0x04, 0x75, 0xe2, 0xee, + 0x9d, 0x9f, 0xfc, 0x7c, 0x55, 0xf9, 0xe9, 0xcf, 0x57, 0x27, 0xfe, 0xef, 0x27, 0xab, 0xca, 0x4f, + 0x3e, 0x59, 0x55, 0xfe, 0xe1, 0x93, 0x55, 0xe5, 0x67, 0x9f, 0xac, 0x2a, 0xdf, 0xfe, 0xd7, 0xd5, + 0x89, 0x8f, 0xd4, 0x47, 0x37, 0xfc, 0xcb, 0x96, 0x73, 0xa5, 0xe3, 0x59, 0x97, 0x0c, 0xd7, 0xba, + 0xe2, 0x3e, 0xea, 0x5e, 0x31, 0x5c, 0xcb, 0xbf, 0xc2, 0xe5, 0x5e, 0x79, 0xfc, 0xea, 0xc3, 0x29, + 0xfa, 0x4f, 0xef, 0x5e, 0xfb, 0xef, 0x00, 0x00, 0x00, 0xff, 0xff, 0xbb, 0x2f, 0xd6, 0x6d, 0xae, + 0x70, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. @@ -10251,6 +10988,14 @@ type RuntimeServiceClient interface { ListMetricDescriptors(ctx context.Context, in *ListMetricDescriptorsRequest, opts ...grpc.CallOption) (*ListMetricDescriptorsResponse, error) // ListPodSandboxMetrics gets pod sandbox metrics from CRI Runtime ListPodSandboxMetrics(ctx context.Context, in *ListPodSandboxMetricsRequest, opts ...grpc.CallOption) (*ListPodSandboxMetricsResponse, error) + // RuntimeConfig returns configuration information of the runtime. + // A couple of notes: + // - The RuntimeConfigRequest object is not to be confused with the contents of UpdateRuntimeConfigRequest. + // The former is for having runtime tell Kubelet what to do, the latter vice versa. + // - It is the expectation of the Kubelet that these fields are static for the lifecycle of the Kubelet. + // The Kubelet will not re-request the RuntimeConfiguration after startup, and CRI implementations should + // avoid updating them without a full node reboot. + RuntimeConfig(ctx context.Context, in *RuntimeConfigRequest, opts ...grpc.CallOption) (*RuntimeConfigResponse, error) } type runtimeServiceClient struct { @@ -10536,6 +11281,15 @@ func (c *runtimeServiceClient) ListPodSandboxMetrics(ctx context.Context, in *Li return out, nil } +func (c *runtimeServiceClient) RuntimeConfig(ctx context.Context, in *RuntimeConfigRequest, opts ...grpc.CallOption) (*RuntimeConfigResponse, error) { + out := new(RuntimeConfigResponse) + err := c.cc.Invoke(ctx, "/runtime.v1.RuntimeService/RuntimeConfig", in, out, opts...) + if err != nil { + return nil, err + } + return out, nil +} + // RuntimeServiceServer is the server API for RuntimeService service. type RuntimeServiceServer interface { // Version returns the runtime name, runtime version, and runtime API version. @@ -10626,6 +11380,14 @@ type RuntimeServiceServer interface { ListMetricDescriptors(context.Context, *ListMetricDescriptorsRequest) (*ListMetricDescriptorsResponse, error) // ListPodSandboxMetrics gets pod sandbox metrics from CRI Runtime ListPodSandboxMetrics(context.Context, *ListPodSandboxMetricsRequest) (*ListPodSandboxMetricsResponse, error) + // RuntimeConfig returns configuration information of the runtime. + // A couple of notes: + // - The RuntimeConfigRequest object is not to be confused with the contents of UpdateRuntimeConfigRequest. + // The former is for having runtime tell Kubelet what to do, the latter vice versa. + // - It is the expectation of the Kubelet that these fields are static for the lifecycle of the Kubelet. + // The Kubelet will not re-request the RuntimeConfiguration after startup, and CRI implementations should + // avoid updating them without a full node reboot. + RuntimeConfig(context.Context, *RuntimeConfigRequest) (*RuntimeConfigResponse, error) } // UnimplementedRuntimeServiceServer can be embedded to have forward compatible implementations. @@ -10716,6 +11478,9 @@ func (*UnimplementedRuntimeServiceServer) ListMetricDescriptors(ctx context.Cont func (*UnimplementedRuntimeServiceServer) ListPodSandboxMetrics(ctx context.Context, req *ListPodSandboxMetricsRequest) (*ListPodSandboxMetricsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ListPodSandboxMetrics not implemented") } +func (*UnimplementedRuntimeServiceServer) RuntimeConfig(ctx context.Context, req *RuntimeConfigRequest) (*RuntimeConfigResponse, error) { + return nil, status.Errorf(codes.Unimplemented, "method RuntimeConfig not implemented") +} func RegisterRuntimeServiceServer(s *grpc.Server, srv RuntimeServiceServer) { s.RegisterService(&_RuntimeService_serviceDesc, srv) @@ -11228,6 +11993,24 @@ func _RuntimeService_ListPodSandboxMetrics_Handler(srv interface{}, ctx context. return interceptor(ctx, in, info, handler) } +func _RuntimeService_RuntimeConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { + in := new(RuntimeConfigRequest) + if err := dec(in); err != nil { + return nil, err + } + if interceptor == nil { + return srv.(RuntimeServiceServer).RuntimeConfig(ctx, in) + } + info := &grpc.UnaryServerInfo{ + Server: srv, + FullMethod: "/runtime.v1.RuntimeService/RuntimeConfig", + } + handler := func(ctx context.Context, req interface{}) (interface{}, error) { + return srv.(RuntimeServiceServer).RuntimeConfig(ctx, req.(*RuntimeConfigRequest)) + } + return interceptor(ctx, in, info, handler) +} + var _RuntimeService_serviceDesc = grpc.ServiceDesc{ ServiceName: "runtime.v1.RuntimeService", HandlerType: (*RuntimeServiceServer)(nil), @@ -11340,6 +12123,10 @@ var _RuntimeService_serviceDesc = grpc.ServiceDesc{ MethodName: "ListPodSandboxMetrics", Handler: _RuntimeService_ListPodSandboxMetrics_Handler, }, + { + MethodName: "RuntimeConfig", + Handler: _RuntimeService_RuntimeConfig_Handler, + }, }, Streams: []grpc.StreamDesc{ { @@ -11781,6 +12568,28 @@ func (m *Mount) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.Image != nil { + { + size, err := m.Image.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x4a + } + if m.RecursiveReadOnly { + i-- + if m.RecursiveReadOnly { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x40 + } if len(m.GidMappings) > 0 { for iNdEx := len(m.GidMappings) - 1; iNdEx >= 0; iNdEx-- { { @@ -12050,6 +12859,11 @@ func (m *LinuxSandboxSecurityContext) MarshalToSizedBuffer(dAtA []byte) (int, er _ = i var l int _ = l + if m.SupplementalGroupsPolicy != 0 { + i = encodeVarintApi(dAtA, i, uint64(m.SupplementalGroupsPolicy)) + i-- + dAtA[i] = 0x58 + } if m.Apparmor != nil { { size, err := m.Apparmor.MarshalToSizedBuffer(dAtA[:i]) @@ -12104,21 +12918,21 @@ func (m *LinuxSandboxSecurityContext) MarshalToSizedBuffer(dAtA []byte) (int, er dAtA[i] = 0x30 } if len(m.SupplementalGroups) > 0 { - dAtA6 := make([]byte, len(m.SupplementalGroups)*10) - var j5 int + dAtA7 := make([]byte, len(m.SupplementalGroups)*10) + var j6 int for _, num1 := range m.SupplementalGroups { num := uint64(num1) for num >= 1<<7 { - dAtA6[j5] = uint8(uint64(num)&0x7f | 0x80) + dAtA7[j6] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j5++ + j6++ } - dAtA6[j5] = uint8(num) - j5++ + dAtA7[j6] = uint8(num) + j6++ } - i -= j5 - copy(dAtA[i:], dAtA6[:j5]) - i = encodeVarintApi(dAtA, i, uint64(j5)) + i -= j6 + copy(dAtA[i:], dAtA7[:j6]) + i = encodeVarintApi(dAtA, i, uint64(j6)) i-- dAtA[i] = 0x2a } @@ -14150,6 +14964,24 @@ func (m *ImageSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if len(m.RuntimeHandler) > 0 { + i -= len(m.RuntimeHandler) + copy(dAtA[i:], m.RuntimeHandler) + i = encodeVarintApi(dAtA, i, uint64(len(m.RuntimeHandler))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x9a + } + if len(m.UserSpecifiedImage) > 0 { + i -= len(m.UserSpecifiedImage) + copy(dAtA[i:], m.UserSpecifiedImage) + i = encodeVarintApi(dAtA, i, uint64(len(m.UserSpecifiedImage))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x92 + } if len(m.Annotations) > 0 { for k := range m.Annotations { v := m.Annotations[k] @@ -14472,6 +15304,13 @@ func (m *LinuxContainerSecurityContext) MarshalToSizedBuffer(dAtA []byte) (int, _ = i var l int _ = l + if m.SupplementalGroupsPolicy != 0 { + i = encodeVarintApi(dAtA, i, uint64(m.SupplementalGroupsPolicy)) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x88 + } if m.Apparmor != nil { { size, err := m.Apparmor.MarshalToSizedBuffer(dAtA[:i]) @@ -14553,21 +15392,21 @@ func (m *LinuxContainerSecurityContext) MarshalToSizedBuffer(dAtA []byte) (int, dAtA[i] = 0x4a } if len(m.SupplementalGroups) > 0 { - dAtA57 := make([]byte, len(m.SupplementalGroups)*10) - var j56 int + dAtA58 := make([]byte, len(m.SupplementalGroups)*10) + var j57 int for _, num1 := range m.SupplementalGroups { num := uint64(num1) for num >= 1<<7 { - dAtA57[j56] = uint8(uint64(num)&0x7f | 0x80) + dAtA58[j57] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j56++ + j57++ } - dAtA57[j56] = uint8(num) - j56++ + dAtA58[j57] = uint8(num) + j57++ } - i -= j56 - copy(dAtA[i:], dAtA57[:j56]) - i = encodeVarintApi(dAtA, i, uint64(j56)) + i -= j57 + copy(dAtA[i:], dAtA58[:j57]) + i = encodeVarintApi(dAtA, i, uint64(j57)) i-- dAtA[i] = 0x42 } @@ -14696,6 +15535,58 @@ func (m *LinuxContainerConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *LinuxContainerUser) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *LinuxContainerUser) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LinuxContainerUser) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if len(m.SupplementalGroups) > 0 { + dAtA66 := make([]byte, len(m.SupplementalGroups)*10) + var j65 int + for _, num1 := range m.SupplementalGroups { + num := uint64(num1) + for num >= 1<<7 { + dAtA66[j65] = uint8(uint64(num)&0x7f | 0x80) + num >>= 7 + j65++ + } + dAtA66[j65] = uint8(num) + j65++ + } + i -= j65 + copy(dAtA[i:], dAtA66[:j65]) + i = encodeVarintApi(dAtA, i, uint64(j65)) + i-- + dAtA[i] = 0x1a + } + if m.Gid != 0 { + i = encodeVarintApi(dAtA, i, uint64(m.Gid)) + i-- + dAtA[i] = 0x10 + } + if m.Uid != 0 { + i = encodeVarintApi(dAtA, i, uint64(m.Uid)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + func (m *WindowsNamespaceOption) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -15699,6 +16590,13 @@ func (m *Container) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if len(m.ImageId) > 0 { + i -= len(m.ImageId) + copy(dAtA[i:], m.ImageId) + i = encodeVarintApi(dAtA, i, uint64(len(m.ImageId))) + i-- + dAtA[i] = 0x52 + } if len(m.Annotations) > 0 { for k := range m.Annotations { v := m.Annotations[k] @@ -15892,6 +16790,29 @@ func (m *ContainerStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.User != nil { + { + size, err := m.User.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x92 + } + if len(m.ImageId) > 0 { + i -= len(m.ImageId) + copy(dAtA[i:], m.ImageId) + i = encodeVarintApi(dAtA, i, uint64(len(m.ImageId))) + i-- + dAtA[i] = 0x1 + i-- + dAtA[i] = 0x8a + } if m.Resources != nil { { size, err := m.Resources.MarshalToSizedBuffer(dAtA[:i]) @@ -16146,6 +17067,41 @@ func (m *ContainerResources) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *ContainerUser) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *ContainerUser) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *ContainerUser) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Linux != nil { + { + size, err := m.Linux.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + func (m *UpdateContainerResourcesRequest) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -16558,21 +17514,21 @@ func (m *PortForwardRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { var l int _ = l if len(m.Port) > 0 { - dAtA87 := make([]byte, len(m.Port)*10) - var j86 int + dAtA92 := make([]byte, len(m.Port)*10) + var j91 int for _, num1 := range m.Port { num := uint64(num1) for num >= 1<<7 { - dAtA87[j86] = uint8(uint64(num)&0x7f | 0x80) + dAtA92[j91] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 - j86++ + j91++ } - dAtA87[j86] = uint8(num) - j86++ + dAtA92[j91] = uint8(num) + j91++ } - i -= j86 - copy(dAtA[i:], dAtA87[:j86]) - i = encodeVarintApi(dAtA, i, uint64(j86)) + i -= j91 + copy(dAtA[i:], dAtA92[:j91]) + i = encodeVarintApi(dAtA, i, uint64(j91)) i-- dAtA[i] = 0x12 } @@ -17375,6 +18331,124 @@ func (m *StatusRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *RuntimeHandlerFeatures) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RuntimeHandlerFeatures) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RuntimeHandlerFeatures) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.UserNamespaces { + i-- + if m.UserNamespaces { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x10 + } + if m.RecursiveReadOnlyMounts { + i-- + if m.RecursiveReadOnlyMounts { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + +func (m *RuntimeHandler) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RuntimeHandler) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RuntimeHandler) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Features != nil { + { + size, err := m.Features.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if len(m.Name) > 0 { + i -= len(m.Name) + copy(dAtA[i:], m.Name) + i = encodeVarintApi(dAtA, i, uint64(len(m.Name))) + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *RuntimeFeatures) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RuntimeFeatures) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RuntimeFeatures) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.SupplementalGroupsPolicy { + i-- + if m.SupplementalGroupsPolicy { + dAtA[i] = 1 + } else { + dAtA[i] = 0 + } + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + func (m *StatusResponse) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -17395,6 +18469,32 @@ func (m *StatusResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.Features != nil { + { + size, err := m.Features.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x22 + } + if len(m.RuntimeHandlers) > 0 { + for iNdEx := len(m.RuntimeHandlers) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.RuntimeHandlers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + } if len(m.Info) > 0 { for k := range m.Info { v := m.Info[k] @@ -17646,6 +18746,20 @@ func (m *ImageFsInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if len(m.ContainerFilesystems) > 0 { + for iNdEx := len(m.ContainerFilesystems) - 1; iNdEx >= 0; iNdEx-- { + { + size, err := m.ContainerFilesystems[iNdEx].MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + } if len(m.ImageFilesystems) > 0 { for iNdEx := len(m.ImageFilesystems) - 1; iNdEx >= 0; iNdEx-- { { @@ -17956,6 +19070,18 @@ func (m *ContainerStats) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.Swap != nil { + { + size, err := m.Swap.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } if m.WritableLayer != nil { { size, err := m.WritableLayer.MarshalToSizedBuffer(dAtA[:i]) @@ -18282,6 +19408,58 @@ func (m *MemoryUsage) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *SwapUsage) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *SwapUsage) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *SwapUsage) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.SwapUsageBytes != nil { + { + size, err := m.SwapUsageBytes.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x1a + } + if m.SwapAvailableBytes != nil { + { + size, err := m.SwapAvailableBytes.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x12 + } + if m.Timestamp != 0 { + i = encodeVarintApi(dAtA, i, uint64(m.Timestamp)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + func (m *WindowsMemoryUsage) Marshal() (dAtA []byte, err error) { size := m.Size() dAtA = make([]byte, size) @@ -18302,6 +19480,18 @@ func (m *WindowsMemoryUsage) MarshalToSizedBuffer(dAtA []byte) (int, error) { _ = i var l int _ = l + if m.CommitMemoryBytes != nil { + { + size, err := m.CommitMemoryBytes.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0x2a + } if m.PageFaults != nil { { size, err := m.PageFaults.MarshalToSizedBuffer(dAtA[:i]) @@ -18882,6 +20072,92 @@ func (m *Metric) MarshalToSizedBuffer(dAtA []byte) (int, error) { return len(dAtA) - i, nil } +func (m *RuntimeConfigRequest) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RuntimeConfigRequest) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RuntimeConfigRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + return len(dAtA) - i, nil +} + +func (m *RuntimeConfigResponse) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *RuntimeConfigResponse) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *RuntimeConfigResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.Linux != nil { + { + size, err := m.Linux.MarshalToSizedBuffer(dAtA[:i]) + if err != nil { + return 0, err + } + i -= size + i = encodeVarintApi(dAtA, i, uint64(size)) + } + i-- + dAtA[i] = 0xa + } + return len(dAtA) - i, nil +} + +func (m *LinuxRuntimeConfiguration) Marshal() (dAtA []byte, err error) { + size := m.Size() + dAtA = make([]byte, size) + n, err := m.MarshalToSizedBuffer(dAtA[:size]) + if err != nil { + return nil, err + } + return dAtA[:n], nil +} + +func (m *LinuxRuntimeConfiguration) MarshalTo(dAtA []byte) (int, error) { + size := m.Size() + return m.MarshalToSizedBuffer(dAtA[:size]) +} + +func (m *LinuxRuntimeConfiguration) MarshalToSizedBuffer(dAtA []byte) (int, error) { + i := len(dAtA) + _ = i + var l int + _ = l + if m.CgroupDriver != 0 { + i = encodeVarintApi(dAtA, i, uint64(m.CgroupDriver)) + i-- + dAtA[i] = 0x8 + } + return len(dAtA) - i, nil +} + func encodeVarintApi(dAtA []byte, offset int, v uint64) int { offset -= sovApi(v) base := offset @@ -19015,6 +20291,13 @@ func (m *Mount) Size() (n int) { n += 1 + l + sovApi(uint64(l)) } } + if m.RecursiveReadOnly { + n += 2 + } + if m.Image != nil { + l = m.Image.Size() + n += 1 + l + sovApi(uint64(l)) + } return n } @@ -19145,6 +20428,9 @@ func (m *LinuxSandboxSecurityContext) Size() (n int) { l = m.Apparmor.Size() n += 1 + l + sovApi(uint64(l)) } + if m.SupplementalGroupsPolicy != 0 { + n += 1 + sovApi(uint64(m.SupplementalGroupsPolicy)) + } return n } @@ -19956,6 +21242,14 @@ func (m *ImageSpec) Size() (n int) { n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) } } + l = len(m.UserSpecifiedImage) + if l > 0 { + n += 2 + l + sovApi(uint64(l)) + } + l = len(m.RuntimeHandler) + if l > 0 { + n += 2 + l + sovApi(uint64(l)) + } return n } @@ -20167,6 +21461,9 @@ func (m *LinuxContainerSecurityContext) Size() (n int) { l = m.Apparmor.Size() n += 2 + l + sovApi(uint64(l)) } + if m.SupplementalGroupsPolicy != 0 { + n += 2 + sovApi(uint64(m.SupplementalGroupsPolicy)) + } return n } @@ -20187,6 +21484,28 @@ func (m *LinuxContainerConfig) Size() (n int) { return n } +func (m *LinuxContainerUser) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Uid != 0 { + n += 1 + sovApi(uint64(m.Uid)) + } + if m.Gid != 0 { + n += 1 + sovApi(uint64(m.Gid)) + } + if len(m.SupplementalGroups) > 0 { + l = 0 + for _, e := range m.SupplementalGroups { + l += sovApi(uint64(e)) + } + n += 1 + sovApi(uint64(l)) + l + } + return n +} + func (m *WindowsNamespaceOption) Size() (n int) { if m == nil { return 0 @@ -20646,6 +21965,10 @@ func (m *Container) Size() (n int) { n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) } } + l = len(m.ImageId) + if l > 0 { + n += 1 + l + sovApi(uint64(l)) + } return n } @@ -20755,6 +22078,14 @@ func (m *ContainerStatus) Size() (n int) { l = m.Resources.Size() n += 2 + l + sovApi(uint64(l)) } + l = len(m.ImageId) + if l > 0 { + n += 2 + l + sovApi(uint64(l)) + } + if m.User != nil { + l = m.User.Size() + n += 2 + l + sovApi(uint64(l)) + } return n } @@ -20796,6 +22127,19 @@ func (m *ContainerResources) Size() (n int) { return n } +func (m *ContainerUser) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Linux != nil { + l = m.Linux.Size() + n += 1 + l + sovApi(uint64(l)) + } + return n +} + func (m *UpdateContainerResourcesRequest) Size() (n int) { if m == nil { return 0 @@ -21300,6 +22644,50 @@ func (m *StatusRequest) Size() (n int) { return n } +func (m *RuntimeHandlerFeatures) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.RecursiveReadOnlyMounts { + n += 2 + } + if m.UserNamespaces { + n += 2 + } + return n +} + +func (m *RuntimeHandler) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + l = len(m.Name) + if l > 0 { + n += 1 + l + sovApi(uint64(l)) + } + if m.Features != nil { + l = m.Features.Size() + n += 1 + l + sovApi(uint64(l)) + } + return n +} + +func (m *RuntimeFeatures) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.SupplementalGroupsPolicy { + n += 2 + } + return n +} + func (m *StatusResponse) Size() (n int) { if m == nil { return 0 @@ -21318,6 +22706,16 @@ func (m *StatusResponse) Size() (n int) { n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) } } + if len(m.RuntimeHandlers) > 0 { + for _, e := range m.RuntimeHandlers { + l = e.Size() + n += 1 + l + sovApi(uint64(l)) + } + } + if m.Features != nil { + l = m.Features.Size() + n += 1 + l + sovApi(uint64(l)) + } return n } @@ -21411,6 +22809,12 @@ func (m *ImageFsInfoResponse) Size() (n int) { n += 1 + l + sovApi(uint64(l)) } } + if len(m.ContainerFilesystems) > 0 { + for _, e := range m.ContainerFilesystems { + l = e.Size() + n += 1 + l + sovApi(uint64(l)) + } + } return n } @@ -21548,6 +22952,10 @@ func (m *ContainerStats) Size() (n int) { l = m.WritableLayer.Size() n += 1 + l + sovApi(uint64(l)) } + if m.Swap != nil { + l = m.Swap.Size() + n += 1 + l + sovApi(uint64(l)) + } return n } @@ -21652,6 +23060,26 @@ func (m *MemoryUsage) Size() (n int) { return n } +func (m *SwapUsage) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Timestamp != 0 { + n += 1 + sovApi(uint64(m.Timestamp)) + } + if m.SwapAvailableBytes != nil { + l = m.SwapAvailableBytes.Size() + n += 1 + l + sovApi(uint64(l)) + } + if m.SwapUsageBytes != nil { + l = m.SwapUsageBytes.Size() + n += 1 + l + sovApi(uint64(l)) + } + return n +} + func (m *WindowsMemoryUsage) Size() (n int) { if m == nil { return 0 @@ -21673,6 +23101,10 @@ func (m *WindowsMemoryUsage) Size() (n int) { l = m.PageFaults.Size() n += 1 + l + sovApi(uint64(l)) } + if m.CommitMemoryBytes != nil { + l = m.CommitMemoryBytes.Size() + n += 1 + l + sovApi(uint64(l)) + } return n } @@ -21909,6 +23341,40 @@ func (m *Metric) Size() (n int) { return n } +func (m *RuntimeConfigRequest) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + return n +} + +func (m *RuntimeConfigResponse) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.Linux != nil { + l = m.Linux.Size() + n += 1 + l + sovApi(uint64(l)) + } + return n +} + +func (m *LinuxRuntimeConfiguration) Size() (n int) { + if m == nil { + return 0 + } + var l int + _ = l + if m.CgroupDriver != 0 { + n += 1 + sovApi(uint64(m.CgroupDriver)) + } + return n +} + func sovApi(x uint64) (n int) { return (math_bits.Len64(x|1) + 6) / 7 } @@ -21985,6 +23451,8 @@ func (this *Mount) String() string { `Propagation:` + fmt.Sprintf("%v", this.Propagation) + `,`, `UidMappings:` + repeatedStringForUidMappings + `,`, `GidMappings:` + repeatedStringForGidMappings + `,`, + `RecursiveReadOnly:` + fmt.Sprintf("%v", this.RecursiveReadOnly) + `,`, + `Image:` + strings.Replace(this.Image.String(), "ImageSpec", "ImageSpec", 1) + `,`, `}`, }, "") return s @@ -22062,6 +23530,7 @@ func (this *LinuxSandboxSecurityContext) String() string { `RunAsGroup:` + strings.Replace(this.RunAsGroup.String(), "Int64Value", "Int64Value", 1) + `,`, `Seccomp:` + strings.Replace(this.Seccomp.String(), "SecurityProfile", "SecurityProfile", 1) + `,`, `Apparmor:` + strings.Replace(this.Apparmor.String(), "SecurityProfile", "SecurityProfile", 1) + `,`, + `SupplementalGroupsPolicy:` + fmt.Sprintf("%v", this.SupplementalGroupsPolicy) + `,`, `}`, }, "") return s @@ -22682,6 +24151,8 @@ func (this *ImageSpec) String() string { s := strings.Join([]string{`&ImageSpec{`, `Image:` + fmt.Sprintf("%v", this.Image) + `,`, `Annotations:` + mapStringForAnnotations + `,`, + `UserSpecifiedImage:` + fmt.Sprintf("%v", this.UserSpecifiedImage) + `,`, + `RuntimeHandler:` + fmt.Sprintf("%v", this.RuntimeHandler) + `,`, `}`, }, "") return s @@ -22788,6 +24259,7 @@ func (this *LinuxContainerSecurityContext) String() string { `ReadonlyPaths:` + fmt.Sprintf("%v", this.ReadonlyPaths) + `,`, `Seccomp:` + strings.Replace(this.Seccomp.String(), "SecurityProfile", "SecurityProfile", 1) + `,`, `Apparmor:` + strings.Replace(this.Apparmor.String(), "SecurityProfile", "SecurityProfile", 1) + `,`, + `SupplementalGroupsPolicy:` + fmt.Sprintf("%v", this.SupplementalGroupsPolicy) + `,`, `}`, }, "") return s @@ -22803,6 +24275,18 @@ func (this *LinuxContainerConfig) String() string { }, "") return s } +func (this *LinuxContainerUser) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&LinuxContainerUser{`, + `Uid:` + fmt.Sprintf("%v", this.Uid) + `,`, + `Gid:` + fmt.Sprintf("%v", this.Gid) + `,`, + `SupplementalGroups:` + fmt.Sprintf("%v", this.SupplementalGroups) + `,`, + `}`, + }, "") + return s +} func (this *WindowsNamespaceOption) String() string { if this == nil { return "nil" @@ -23129,6 +24613,7 @@ func (this *Container) String() string { `CreatedAt:` + fmt.Sprintf("%v", this.CreatedAt) + `,`, `Labels:` + mapStringForLabels + `,`, `Annotations:` + mapStringForAnnotations + `,`, + `ImageId:` + fmt.Sprintf("%v", this.ImageId) + `,`, `}`, }, "") return s @@ -23205,6 +24690,8 @@ func (this *ContainerStatus) String() string { `Mounts:` + repeatedStringForMounts + `,`, `LogPath:` + fmt.Sprintf("%v", this.LogPath) + `,`, `Resources:` + strings.Replace(this.Resources.String(), "ContainerResources", "ContainerResources", 1) + `,`, + `ImageId:` + fmt.Sprintf("%v", this.ImageId) + `,`, + `User:` + strings.Replace(this.User.String(), "ContainerUser", "ContainerUser", 1) + `,`, `}`, }, "") return s @@ -23241,6 +24728,16 @@ func (this *ContainerResources) String() string { }, "") return s } +func (this *ContainerUser) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&ContainerUser{`, + `Linux:` + strings.Replace(this.Linux.String(), "LinuxContainerUser", "LinuxContainerUser", 1) + `,`, + `}`, + }, "") + return s +} func (this *UpdateContainerResourcesRequest) String() string { if this == nil { return "nil" @@ -23584,10 +25081,47 @@ func (this *StatusRequest) String() string { }, "") return s } +func (this *RuntimeHandlerFeatures) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&RuntimeHandlerFeatures{`, + `RecursiveReadOnlyMounts:` + fmt.Sprintf("%v", this.RecursiveReadOnlyMounts) + `,`, + `UserNamespaces:` + fmt.Sprintf("%v", this.UserNamespaces) + `,`, + `}`, + }, "") + return s +} +func (this *RuntimeHandler) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&RuntimeHandler{`, + `Name:` + fmt.Sprintf("%v", this.Name) + `,`, + `Features:` + strings.Replace(this.Features.String(), "RuntimeHandlerFeatures", "RuntimeHandlerFeatures", 1) + `,`, + `}`, + }, "") + return s +} +func (this *RuntimeFeatures) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&RuntimeFeatures{`, + `SupplementalGroupsPolicy:` + fmt.Sprintf("%v", this.SupplementalGroupsPolicy) + `,`, + `}`, + }, "") + return s +} func (this *StatusResponse) String() string { if this == nil { return "nil" } + repeatedStringForRuntimeHandlers := "[]*RuntimeHandler{" + for _, f := range this.RuntimeHandlers { + repeatedStringForRuntimeHandlers += strings.Replace(f.String(), "RuntimeHandler", "RuntimeHandler", 1) + "," + } + repeatedStringForRuntimeHandlers += "}" keysForInfo := make([]string, 0, len(this.Info)) for k := range this.Info { keysForInfo = append(keysForInfo, k) @@ -23601,6 +25135,8 @@ func (this *StatusResponse) String() string { s := strings.Join([]string{`&StatusResponse{`, `Status:` + strings.Replace(this.Status.String(), "RuntimeStatus", "RuntimeStatus", 1) + `,`, `Info:` + mapStringForInfo + `,`, + `RuntimeHandlers:` + repeatedStringForRuntimeHandlers + `,`, + `Features:` + strings.Replace(this.Features.String(), "RuntimeFeatures", "RuntimeFeatures", 1) + `,`, `}`, }, "") return s @@ -23668,8 +25204,14 @@ func (this *ImageFsInfoResponse) String() string { repeatedStringForImageFilesystems += strings.Replace(f.String(), "FilesystemUsage", "FilesystemUsage", 1) + "," } repeatedStringForImageFilesystems += "}" + repeatedStringForContainerFilesystems := "[]*FilesystemUsage{" + for _, f := range this.ContainerFilesystems { + repeatedStringForContainerFilesystems += strings.Replace(f.String(), "FilesystemUsage", "FilesystemUsage", 1) + "," + } + repeatedStringForContainerFilesystems += "}" s := strings.Join([]string{`&ImageFsInfoResponse{`, `ImageFilesystems:` + repeatedStringForImageFilesystems + `,`, + `ContainerFilesystems:` + repeatedStringForContainerFilesystems + `,`, `}`, }, "") return s @@ -23783,6 +25325,7 @@ func (this *ContainerStats) String() string { `Cpu:` + strings.Replace(this.Cpu.String(), "CpuUsage", "CpuUsage", 1) + `,`, `Memory:` + strings.Replace(this.Memory.String(), "MemoryUsage", "MemoryUsage", 1) + `,`, `WritableLayer:` + strings.Replace(this.WritableLayer.String(), "FilesystemUsage", "FilesystemUsage", 1) + `,`, + `Swap:` + strings.Replace(this.Swap.String(), "SwapUsage", "SwapUsage", 1) + `,`, `}`, }, "") return s @@ -23840,6 +25383,18 @@ func (this *MemoryUsage) String() string { }, "") return s } +func (this *SwapUsage) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&SwapUsage{`, + `Timestamp:` + fmt.Sprintf("%v", this.Timestamp) + `,`, + `SwapAvailableBytes:` + strings.Replace(this.SwapAvailableBytes.String(), "UInt64Value", "UInt64Value", 1) + `,`, + `SwapUsageBytes:` + strings.Replace(this.SwapUsageBytes.String(), "UInt64Value", "UInt64Value", 1) + `,`, + `}`, + }, "") + return s +} func (this *WindowsMemoryUsage) String() string { if this == nil { return "nil" @@ -23849,6 +25404,7 @@ func (this *WindowsMemoryUsage) String() string { `WorkingSetBytes:` + strings.Replace(this.WorkingSetBytes.String(), "UInt64Value", "UInt64Value", 1) + `,`, `AvailableBytes:` + strings.Replace(this.AvailableBytes.String(), "UInt64Value", "UInt64Value", 1) + `,`, `PageFaults:` + strings.Replace(this.PageFaults.String(), "UInt64Value", "UInt64Value", 1) + `,`, + `CommitMemoryBytes:` + strings.Replace(this.CommitMemoryBytes.String(), "UInt64Value", "UInt64Value", 1) + `,`, `}`, }, "") return s @@ -24033,6 +25589,35 @@ func (this *Metric) String() string { }, "") return s } +func (this *RuntimeConfigRequest) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&RuntimeConfigRequest{`, + `}`, + }, "") + return s +} +func (this *RuntimeConfigResponse) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&RuntimeConfigResponse{`, + `Linux:` + strings.Replace(this.Linux.String(), "LinuxRuntimeConfiguration", "LinuxRuntimeConfiguration", 1) + `,`, + `}`, + }, "") + return s +} +func (this *LinuxRuntimeConfiguration) String() string { + if this == nil { + return "nil" + } + s := strings.Join([]string{`&LinuxRuntimeConfiguration{`, + `CgroupDriver:` + fmt.Sprintf("%v", this.CgroupDriver) + `,`, + `}`, + }, "") + return s +} func valueToStringApi(v interface{}) string { rv := reflect.ValueOf(v) if rv.IsNil() { @@ -24806,61 +26391,11 @@ func (m *Mount) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipApi(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthApi - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *IDMapping) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowApi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: IDMapping: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: IDMapping: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + case 8: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field HostId", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RecursiveReadOnly", wireType) } - m.HostId = 0 + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi @@ -24870,16 +26405,17 @@ func (m *IDMapping) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.HostId |= uint32(b&0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", wireType) + m.RecursiveReadOnly = bool(v != 0) + case 9: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Image", wireType) } - m.ContainerId = 0 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi @@ -24889,30 +26425,28 @@ func (m *IDMapping) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.ContainerId |= uint32(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Length", wireType) + if msglen < 0 { + return ErrInvalidLengthApi } - m.Length = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowApi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Length |= uint32(b&0x7F) << shift - if b < 0x80 { - break - } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Image == nil { + m.Image = &ImageSpec{} + } + if err := m.Image.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipApi(dAtA[iNdEx:]) @@ -24934,7 +26468,7 @@ func (m *IDMapping) Unmarshal(dAtA []byte) error { } return nil } -func (m *UserNamespace) Unmarshal(dAtA []byte) error { +func (m *IDMapping) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -24957,17 +26491,17 @@ func (m *UserNamespace) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: UserNamespace: wiretype end group for non-group") + return fmt.Errorf("proto: IDMapping: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: UserNamespace: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: IDMapping: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field HostId", wireType) } - m.Mode = 0 + m.HostId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi @@ -24977,16 +26511,16 @@ func (m *UserNamespace) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.Mode |= NamespaceMode(b&0x7F) << shift + m.HostId |= uint32(b&0x7F) << shift if b < 0x80 { break } } case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Uids", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", wireType) } - var msglen int + m.ContainerId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi @@ -24996,31 +26530,16 @@ func (m *UserNamespace) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.ContainerId |= uint32(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthApi - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthApi - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Uids = append(m.Uids, &IDMapping{}) - if err := m.Uids[len(m.Uids)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Gids", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Length", wireType) } - var msglen int + m.Length = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi @@ -25030,26 +26549,148 @@ func (m *UserNamespace) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.Length |= uint32(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthApi - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthApi - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Gids = append(m.Gids, &IDMapping{}) - if err := m.Gids[len(m.Gids)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApi + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *UserNamespace) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: UserNamespace: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: UserNamespace: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType) + } + m.Mode = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Mode |= NamespaceMode(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Uids", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Uids = append(m.Uids, &IDMapping{}) + if err := m.Uids[len(m.Uids)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Gids", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Gids = append(m.Gids, &IDMapping{}) + if err := m.Gids[len(m.Gids)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipApi(dAtA[iNdEx:]) @@ -25708,6 +27349,25 @@ func (m *LinuxSandboxSecurityContext) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 11: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SupplementalGroupsPolicy", wireType) + } + m.SupplementalGroupsPolicy = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.SupplementalGroupsPolicy |= SupplementalGroupsPolicy(b&0x7F) << shift + if b < 0x80 { + break + } + } default: iNdEx = preIndex skippy, err := skipApi(dAtA[iNdEx:]) @@ -32161,59 +33821,9 @@ func (m *ImageSpec) Unmarshal(dAtA []byte) error { } m.Annotations[mapkey] = mapvalue iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipApi(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthApi - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *KeyValue) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowApi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: KeyValue: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: KeyValue: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + case 18: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UserSpecifiedImage", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -32241,11 +33851,11 @@ func (m *KeyValue) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Key = string(dAtA[iNdEx:postIndex]) + m.UserSpecifiedImage = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - case 2: + case 19: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RuntimeHandler", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -32273,7 +33883,7 @@ func (m *KeyValue) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Value = string(dAtA[iNdEx:postIndex]) + m.RuntimeHandler = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -32296,7 +33906,7 @@ func (m *KeyValue) Unmarshal(dAtA []byte) error { } return nil } -func (m *LinuxContainerResources) Unmarshal(dAtA []byte) error { +func (m *KeyValue) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -32319,55 +33929,17 @@ func (m *LinuxContainerResources) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: LinuxContainerResources: wiretype end group for non-group") + return fmt.Errorf("proto: KeyValue: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: LinuxContainerResources: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: KeyValue: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field CpuPeriod", wireType) - } - m.CpuPeriod = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowApi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.CpuPeriod |= int64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field CpuQuota", wireType) - } - m.CpuQuota = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowApi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.CpuQuota |= int64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 3: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field CpuShares", wireType) + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType) } - m.CpuShares = 0 + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi @@ -32377,52 +33949,204 @@ func (m *LinuxContainerResources) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - m.CpuShares |= int64(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - case 4: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field MemoryLimitInBytes", wireType) - } - m.MemoryLimitInBytes = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowApi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.MemoryLimitInBytes |= int64(b&0x7F) << shift - if b < 0x80 { - break - } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthApi } - case 5: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field OomScoreAdj", wireType) + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthApi } - m.OomScoreAdj = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowApi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.OomScoreAdj |= int64(b&0x7F) << shift - if b < 0x80 { - break - } + if postIndex > l { + return io.ErrUnexpectedEOF } - case 6: + m.Key = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field CpusetCpus", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Value = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApi + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LinuxContainerResources) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: LinuxContainerResources: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LinuxContainerResources: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CpuPeriod", wireType) + } + m.CpuPeriod = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CpuPeriod |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CpuQuota", wireType) + } + m.CpuQuota = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CpuQuota |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CpuShares", wireType) + } + m.CpuShares = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CpuShares |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 4: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field MemoryLimitInBytes", wireType) + } + m.MemoryLimitInBytes = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.MemoryLimitInBytes |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 5: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field OomScoreAdj", wireType) + } + m.OomScoreAdj = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.OomScoreAdj |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 6: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field CpusetCpus", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -33687,97 +35411,11 @@ func (m *LinuxContainerSecurityContext) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipApi(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthApi - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *LinuxContainerConfig) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowApi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: LinuxContainerConfig: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: LinuxContainerConfig: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowApi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthApi - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthApi - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Resources == nil { - m.Resources = &LinuxContainerResources{} - } - if err := m.Resources.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SecurityContext", wireType) + case 17: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field SupplementalGroupsPolicy", wireType) } - var msglen int + m.SupplementalGroupsPolicy = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi @@ -33787,28 +35425,297 @@ func (m *LinuxContainerConfig) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + m.SupplementalGroupsPolicy |= SupplementalGroupsPolicy(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { - return ErrInvalidLengthApi - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthApi - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.SecurityContext == nil { - m.SecurityContext = &LinuxContainerSecurityContext{} - } - if err := m.SecurityContext.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApi + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LinuxContainerConfig) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: LinuxContainerConfig: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LinuxContainerConfig: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Resources", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Resources == nil { + m.Resources = &LinuxContainerResources{} + } + if err := m.Resources.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SecurityContext", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SecurityContext == nil { + m.SecurityContext = &LinuxContainerSecurityContext{} + } + if err := m.SecurityContext.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApi + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LinuxContainerUser) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: LinuxContainerUser: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LinuxContainerUser: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Uid", wireType) + } + m.Uid = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Uid |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Gid", wireType) + } + m.Gid = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Gid |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 3: + if wireType == 0 { + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.SupplementalGroups = append(m.SupplementalGroups, v) + } else if wireType == 2 { + var packedLen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + packedLen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if packedLen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + packedLen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + var elementCount int + var count int + for _, integer := range dAtA[iNdEx:postIndex] { + if integer < 128 { + count++ + } + } + elementCount = count + if elementCount != 0 && len(m.SupplementalGroups) == 0 { + m.SupplementalGroups = make([]int64, 0, elementCount) + } + for iNdEx < postIndex { + var v int64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.SupplementalGroups = append(m.SupplementalGroups, v) + } + } else { + return fmt.Errorf("proto: wrong wireType = %d for field SupplementalGroups", wireType) + } default: iNdEx = preIndex skippy, err := skipApi(dAtA[iNdEx:]) @@ -37229,6 +39136,38 @@ func (m *Container) Unmarshal(dAtA []byte) error { } m.Annotations[mapkey] = mapvalue iNdEx = postIndex + case 10: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ImageId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ImageId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipApi(dAtA[iNdEx:]) @@ -38116,6 +40055,74 @@ func (m *ContainerStatus) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 17: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ImageId", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ImageId = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 18: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field User", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.User == nil { + m.User = &ContainerUser{} + } + if err := m.User.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipApi(dAtA[iNdEx:]) @@ -38472,6 +40479,92 @@ func (m *ContainerResources) Unmarshal(dAtA []byte) error { } return nil } +func (m *ContainerUser) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: ContainerUser: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: ContainerUser: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Linux", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Linux == nil { + m.Linux = &LinuxContainerUser{} + } + if err := m.Linux.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApi + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func (m *UpdateContainerResourcesRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 @@ -40962,89 +43055,393 @@ func (m *PullImageRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: PullImageRequest: wiretype end group for non-group") + return fmt.Errorf("proto: PullImageRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PullImageRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Image", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Image == nil { + m.Image = &ImageSpec{} + } + if err := m.Image.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Auth", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Auth == nil { + m.Auth = &AuthConfig{} + } + if err := m.Auth.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SandboxConfig", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SandboxConfig == nil { + m.SandboxConfig = &PodSandboxConfig{} + } + if err := m.SandboxConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApi + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *PullImageResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: PullImageResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: PullImageResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ImageRef", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ImageRef = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApi + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RemoveImageRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RemoveImageRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RemoveImageRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Image", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Image == nil { + m.Image = &ImageSpec{} + } + if err := m.Image.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApi + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RemoveImageResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RemoveImageResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RemoveImageResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApi + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *NetworkConfig) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: NetworkConfig: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: PullImageRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: NetworkConfig: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Image", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowApi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthApi - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthApi - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Image == nil { - m.Image = &ImageSpec{} - } - if err := m.Image.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 2: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Auth", wireType) - } - var msglen int - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowApi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - msglen |= int(b&0x7F) << shift - if b < 0x80 { - break - } - } - if msglen < 0 { - return ErrInvalidLengthApi - } - postIndex := iNdEx + msglen - if postIndex < 0 { - return ErrInvalidLengthApi - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - if m.Auth == nil { - m.Auth = &AuthConfig{} - } - if err := m.Auth.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } - iNdEx = postIndex - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field SandboxConfig", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PodCidr", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi @@ -41054,27 +43451,23 @@ func (m *PullImageRequest) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthApi } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthApi } if postIndex > l { return io.ErrUnexpectedEOF } - if m.SandboxConfig == nil { - m.SandboxConfig = &PodSandboxConfig{} - } - if err := m.SandboxConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.PodCidr = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -41097,7 +43490,7 @@ func (m *PullImageRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *PullImageResponse) Unmarshal(dAtA []byte) error { +func (m *RuntimeConfig) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -41120,17 +43513,17 @@ func (m *PullImageResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: PullImageResponse: wiretype end group for non-group") + return fmt.Errorf("proto: RuntimeConfig: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: PullImageResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RuntimeConfig: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field ImageRef", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field NetworkConfig", wireType) } - var stringLen uint64 + var msglen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi @@ -41140,23 +43533,27 @@ func (m *PullImageResponse) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + msglen |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { + if msglen < 0 { return ErrInvalidLengthApi } - postIndex := iNdEx + intStringLen + postIndex := iNdEx + msglen if postIndex < 0 { return ErrInvalidLengthApi } if postIndex > l { return io.ErrUnexpectedEOF } - m.ImageRef = string(dAtA[iNdEx:postIndex]) + if m.NetworkConfig == nil { + m.NetworkConfig = &NetworkConfig{} + } + if err := m.NetworkConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } iNdEx = postIndex default: iNdEx = preIndex @@ -41179,7 +43576,7 @@ func (m *PullImageResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *RemoveImageRequest) Unmarshal(dAtA []byte) error { +func (m *UpdateRuntimeConfigRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -41202,15 +43599,15 @@ func (m *RemoveImageRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: RemoveImageRequest: wiretype end group for non-group") + return fmt.Errorf("proto: UpdateRuntimeConfigRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: RemoveImageRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: UpdateRuntimeConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Image", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field RuntimeConfig", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -41237,10 +43634,10 @@ func (m *RemoveImageRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Image == nil { - m.Image = &ImageSpec{} + if m.RuntimeConfig == nil { + m.RuntimeConfig = &RuntimeConfig{} } - if err := m.Image.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.RuntimeConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -41265,7 +43662,7 @@ func (m *RemoveImageRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *RemoveImageResponse) Unmarshal(dAtA []byte) error { +func (m *UpdateRuntimeConfigResponse) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -41288,10 +43685,10 @@ func (m *RemoveImageResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: RemoveImageResponse: wiretype end group for non-group") + return fmt.Errorf("proto: UpdateRuntimeConfigResponse: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: RemoveImageResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: UpdateRuntimeConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { default: @@ -41315,7 +43712,7 @@ func (m *RemoveImageResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *NetworkConfig) Unmarshal(dAtA []byte) error { +func (m *RuntimeCondition) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -41338,15 +43735,15 @@ func (m *NetworkConfig) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: NetworkConfig: wiretype end group for non-group") + return fmt.Errorf("proto: RuntimeCondition: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: NetworkConfig: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RuntimeCondition: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PodCidr", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) } var stringLen uint64 for shift := uint(0); ; shift += 7 { @@ -41374,63 +43771,65 @@ func (m *NetworkConfig) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.PodCidr = string(dAtA[iNdEx:postIndex]) + m.Type = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipApi(dAtA[iNdEx:]) - if err != nil { - return err + case 2: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthApi + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF + m.Status = bool(v != 0) + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *RuntimeConfig) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowApi + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } } - if iNdEx >= l { - return io.ErrUnexpectedEOF + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthApi } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthApi } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: RuntimeConfig: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: RuntimeConfig: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Reason = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field NetworkConfig", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) } - var msglen int + var stringLen uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi @@ -41440,27 +43839,23 @@ func (m *RuntimeConfig) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - msglen |= int(b&0x7F) << shift + stringLen |= uint64(b&0x7F) << shift if b < 0x80 { break } } - if msglen < 0 { + intStringLen := int(stringLen) + if intStringLen < 0 { return ErrInvalidLengthApi } - postIndex := iNdEx + msglen + postIndex := iNdEx + intStringLen if postIndex < 0 { return ErrInvalidLengthApi } if postIndex > l { return io.ErrUnexpectedEOF } - if m.NetworkConfig == nil { - m.NetworkConfig = &NetworkConfig{} - } - if err := m.NetworkConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { - return err - } + m.Message = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex default: iNdEx = preIndex @@ -41483,7 +43878,7 @@ func (m *RuntimeConfig) Unmarshal(dAtA []byte) error { } return nil } -func (m *UpdateRuntimeConfigRequest) Unmarshal(dAtA []byte) error { +func (m *RuntimeStatus) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -41506,15 +43901,15 @@ func (m *UpdateRuntimeConfigRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: UpdateRuntimeConfigRequest: wiretype end group for non-group") + return fmt.Errorf("proto: RuntimeStatus: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: UpdateRuntimeConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RuntimeStatus: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field RuntimeConfig", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -41541,10 +43936,8 @@ func (m *UpdateRuntimeConfigRequest) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.RuntimeConfig == nil { - m.RuntimeConfig = &RuntimeConfig{} - } - if err := m.RuntimeConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + m.Conditions = append(m.Conditions, &RuntimeCondition{}) + if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -41569,7 +43962,7 @@ func (m *UpdateRuntimeConfigRequest) Unmarshal(dAtA []byte) error { } return nil } -func (m *UpdateRuntimeConfigResponse) Unmarshal(dAtA []byte) error { +func (m *StatusRequest) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -41592,12 +43985,32 @@ func (m *UpdateRuntimeConfigResponse) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: UpdateRuntimeConfigResponse: wiretype end group for non-group") + return fmt.Errorf("proto: StatusRequest: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: UpdateRuntimeConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: StatusRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Verbose", wireType) + } + var v int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + v |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + m.Verbose = bool(v != 0) default: iNdEx = preIndex skippy, err := skipApi(dAtA[iNdEx:]) @@ -41619,7 +44032,7 @@ func (m *UpdateRuntimeConfigResponse) Unmarshal(dAtA []byte) error { } return nil } -func (m *RuntimeCondition) Unmarshal(dAtA []byte) error { +func (m *RuntimeHandlerFeatures) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -41642,17 +44055,17 @@ func (m *RuntimeCondition) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: RuntimeCondition: wiretype end group for non-group") + return fmt.Errorf("proto: RuntimeHandlerFeatures: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: RuntimeCondition: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RuntimeHandlerFeatures: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType) + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field RecursiveReadOnlyMounts", wireType) } - var stringLen uint64 + var v int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi @@ -41662,27 +44075,15 @@ func (m *RuntimeCondition) Unmarshal(dAtA []byte) error { } b := dAtA[iNdEx] iNdEx++ - stringLen |= uint64(b&0x7F) << shift + v |= int(b&0x7F) << shift if b < 0x80 { break } } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthApi - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthApi - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Type = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex + m.RecursiveReadOnlyMounts = bool(v != 0) case 2: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Status", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field UserNamespaces", wireType) } var v int for shift := uint(0); ; shift += 7 { @@ -41699,71 +44100,7 @@ func (m *RuntimeCondition) Unmarshal(dAtA []byte) error { break } } - m.Status = bool(v != 0) - case 3: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Reason", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowApi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthApi - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthApi - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Reason = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex - case 4: - if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Message", wireType) - } - var stringLen uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowApi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - stringLen |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - intStringLen := int(stringLen) - if intStringLen < 0 { - return ErrInvalidLengthApi - } - postIndex := iNdEx + intStringLen - if postIndex < 0 { - return ErrInvalidLengthApi - } - if postIndex > l { - return io.ErrUnexpectedEOF - } - m.Message = string(dAtA[iNdEx:postIndex]) - iNdEx = postIndex + m.UserNamespaces = bool(v != 0) default: iNdEx = preIndex skippy, err := skipApi(dAtA[iNdEx:]) @@ -41785,7 +44122,7 @@ func (m *RuntimeCondition) Unmarshal(dAtA []byte) error { } return nil } -func (m *RuntimeStatus) Unmarshal(dAtA []byte) error { +func (m *RuntimeHandler) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -41808,15 +44145,47 @@ func (m *RuntimeStatus) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: RuntimeStatus: wiretype end group for non-group") + return fmt.Errorf("proto: RuntimeHandler: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: RuntimeStatus: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RuntimeHandler: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Conditions", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType) + } + var stringLen uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + stringLen |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + intStringLen := int(stringLen) + if intStringLen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + intStringLen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.Name = string(dAtA[iNdEx:postIndex]) + iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Features", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -41843,8 +44212,10 @@ func (m *RuntimeStatus) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - m.Conditions = append(m.Conditions, &RuntimeCondition{}) - if err := m.Conditions[len(m.Conditions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if m.Features == nil { + m.Features = &RuntimeHandlerFeatures{} + } + if err := m.Features.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -41869,7 +44240,7 @@ func (m *RuntimeStatus) Unmarshal(dAtA []byte) error { } return nil } -func (m *StatusRequest) Unmarshal(dAtA []byte) error { +func (m *RuntimeFeatures) Unmarshal(dAtA []byte) error { l := len(dAtA) iNdEx := 0 for iNdEx < l { @@ -41892,15 +44263,15 @@ func (m *StatusRequest) Unmarshal(dAtA []byte) error { fieldNum := int32(wire >> 3) wireType := int(wire & 0x7) if wireType == 4 { - return fmt.Errorf("proto: StatusRequest: wiretype end group for non-group") + return fmt.Errorf("proto: RuntimeFeatures: wiretype end group for non-group") } if fieldNum <= 0 { - return fmt.Errorf("proto: StatusRequest: illegal tag %d (wire type %d)", fieldNum, wire) + return fmt.Errorf("proto: RuntimeFeatures: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Verbose", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field SupplementalGroupsPolicy", wireType) } var v int for shift := uint(0); ; shift += 7 { @@ -41917,7 +44288,7 @@ func (m *StatusRequest) Unmarshal(dAtA []byte) error { break } } - m.Verbose = bool(v != 0) + m.SupplementalGroupsPolicy = bool(v != 0) default: iNdEx = preIndex skippy, err := skipApi(dAtA[iNdEx:]) @@ -42131,6 +44502,76 @@ func (m *StatusResponse) Unmarshal(dAtA []byte) error { } m.Info[mapkey] = mapvalue iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field RuntimeHandlers", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.RuntimeHandlers = append(m.RuntimeHandlers, &RuntimeHandler{}) + if err := m.RuntimeHandlers[len(m.RuntimeHandlers)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 4: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Features", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Features == nil { + m.Features = &RuntimeFeatures{} + } + if err := m.Features.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipApi(dAtA[iNdEx:]) @@ -42734,6 +45175,40 @@ func (m *ImageFsInfoResponse) Unmarshal(dAtA []byte) error { return err } iNdEx = postIndex + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field ContainerFilesystems", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + m.ContainerFilesystems = append(m.ContainerFilesystems, &FilesystemUsage{}) + if err := m.ContainerFilesystems[len(m.ContainerFilesystems)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex default: iNdEx = preIndex skippy, err := skipApi(dAtA[iNdEx:]) @@ -43800,16 +46275,52 @@ func (m *ContainerStats) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Cpu == nil { - m.Cpu = &CpuUsage{} + if m.Cpu == nil { + m.Cpu = &CpuUsage{} + } + if err := m.Cpu.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Memory", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Memory == nil { + m.Memory = &MemoryUsage{} } - if err := m.Cpu.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Memory.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 3: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field Memory", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field WritableLayer", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -43836,16 +46347,16 @@ func (m *ContainerStats) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.Memory == nil { - m.Memory = &MemoryUsage{} + if m.WritableLayer == nil { + m.WritableLayer = &FilesystemUsage{} } - if err := m.Memory.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.WritableLayer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 4: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field WritableLayer", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field Swap", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -43872,10 +46383,10 @@ func (m *ContainerStats) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.WritableLayer == nil { - m.WritableLayer = &FilesystemUsage{} + if m.Swap == nil { + m.Swap = &SwapUsage{} } - if err := m.WritableLayer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.Swap.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -44633,85 +47144,262 @@ func (m *MemoryUsage) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.MajorPageFaults == nil { - m.MajorPageFaults = &UInt64Value{} + if m.MajorPageFaults == nil { + m.MajorPageFaults = &UInt64Value{} + } + if err := m.MajorPageFaults.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApi + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *SwapUsage) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: SwapUsage: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: SwapUsage: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + } + m.Timestamp = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Timestamp |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SwapAvailableBytes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SwapAvailableBytes == nil { + m.SwapAvailableBytes = &UInt64Value{} + } + if err := m.SwapAvailableBytes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + case 3: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field SwapUsageBytes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.SwapUsageBytes == nil { + m.SwapUsageBytes = &UInt64Value{} + } + if err := m.SwapUsageBytes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApi + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *WindowsMemoryUsage) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: WindowsMemoryUsage: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: WindowsMemoryUsage: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) + } + m.Timestamp = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.Timestamp |= int64(b&0x7F) << shift + if b < 0x80 { + break + } + } + case 2: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field WorkingSetBytes", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.WorkingSetBytes == nil { + m.WorkingSetBytes = &UInt64Value{} } - if err := m.MajorPageFaults.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.WorkingSetBytes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - default: - iNdEx = preIndex - skippy, err := skipApi(dAtA[iNdEx:]) - if err != nil { - return err - } - if (skippy < 0) || (iNdEx+skippy) < 0 { - return ErrInvalidLengthApi - } - if (iNdEx + skippy) > l { - return io.ErrUnexpectedEOF - } - iNdEx += skippy - } - } - - if iNdEx > l { - return io.ErrUnexpectedEOF - } - return nil -} -func (m *WindowsMemoryUsage) Unmarshal(dAtA []byte) error { - l := len(dAtA) - iNdEx := 0 - for iNdEx < l { - preIndex := iNdEx - var wire uint64 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowApi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - wire |= uint64(b&0x7F) << shift - if b < 0x80 { - break - } - } - fieldNum := int32(wire >> 3) - wireType := int(wire & 0x7) - if wireType == 4 { - return fmt.Errorf("proto: WindowsMemoryUsage: wiretype end group for non-group") - } - if fieldNum <= 0 { - return fmt.Errorf("proto: WindowsMemoryUsage: illegal tag %d (wire type %d)", fieldNum, wire) - } - switch fieldNum { - case 1: - if wireType != 0 { - return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType) - } - m.Timestamp = 0 - for shift := uint(0); ; shift += 7 { - if shift >= 64 { - return ErrIntOverflowApi - } - if iNdEx >= l { - return io.ErrUnexpectedEOF - } - b := dAtA[iNdEx] - iNdEx++ - m.Timestamp |= int64(b&0x7F) << shift - if b < 0x80 { - break - } - } - case 2: + case 3: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field WorkingSetBytes", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field AvailableBytes", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -44738,16 +47426,16 @@ func (m *WindowsMemoryUsage) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.WorkingSetBytes == nil { - m.WorkingSetBytes = &UInt64Value{} + if m.AvailableBytes == nil { + m.AvailableBytes = &UInt64Value{} } - if err := m.WorkingSetBytes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.AvailableBytes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 3: + case 4: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field AvailableBytes", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field PageFaults", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -44774,16 +47462,16 @@ func (m *WindowsMemoryUsage) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.AvailableBytes == nil { - m.AvailableBytes = &UInt64Value{} + if m.PageFaults == nil { + m.PageFaults = &UInt64Value{} } - if err := m.AvailableBytes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.PageFaults.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex - case 4: + case 5: if wireType != 2 { - return fmt.Errorf("proto: wrong wireType = %d for field PageFaults", wireType) + return fmt.Errorf("proto: wrong wireType = %d for field CommitMemoryBytes", wireType) } var msglen int for shift := uint(0); ; shift += 7 { @@ -44810,10 +47498,10 @@ func (m *WindowsMemoryUsage) Unmarshal(dAtA []byte) error { if postIndex > l { return io.ErrUnexpectedEOF } - if m.PageFaults == nil { - m.PageFaults = &UInt64Value{} + if m.CommitMemoryBytes == nil { + m.CommitMemoryBytes = &UInt64Value{} } - if err := m.PageFaults.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + if err := m.CommitMemoryBytes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex @@ -46261,6 +48949,211 @@ func (m *Metric) Unmarshal(dAtA []byte) error { } return nil } +func (m *RuntimeConfigRequest) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RuntimeConfigRequest: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RuntimeConfigRequest: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApi + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *RuntimeConfigResponse) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: RuntimeConfigResponse: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: RuntimeConfigResponse: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 2 { + return fmt.Errorf("proto: wrong wireType = %d for field Linux", wireType) + } + var msglen int + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + msglen |= int(b&0x7F) << shift + if b < 0x80 { + break + } + } + if msglen < 0 { + return ErrInvalidLengthApi + } + postIndex := iNdEx + msglen + if postIndex < 0 { + return ErrInvalidLengthApi + } + if postIndex > l { + return io.ErrUnexpectedEOF + } + if m.Linux == nil { + m.Linux = &LinuxRuntimeConfiguration{} + } + if err := m.Linux.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { + return err + } + iNdEx = postIndex + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApi + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} +func (m *LinuxRuntimeConfiguration) Unmarshal(dAtA []byte) error { + l := len(dAtA) + iNdEx := 0 + for iNdEx < l { + preIndex := iNdEx + var wire uint64 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + wire |= uint64(b&0x7F) << shift + if b < 0x80 { + break + } + } + fieldNum := int32(wire >> 3) + wireType := int(wire & 0x7) + if wireType == 4 { + return fmt.Errorf("proto: LinuxRuntimeConfiguration: wiretype end group for non-group") + } + if fieldNum <= 0 { + return fmt.Errorf("proto: LinuxRuntimeConfiguration: illegal tag %d (wire type %d)", fieldNum, wire) + } + switch fieldNum { + case 1: + if wireType != 0 { + return fmt.Errorf("proto: wrong wireType = %d for field CgroupDriver", wireType) + } + m.CgroupDriver = 0 + for shift := uint(0); ; shift += 7 { + if shift >= 64 { + return ErrIntOverflowApi + } + if iNdEx >= l { + return io.ErrUnexpectedEOF + } + b := dAtA[iNdEx] + iNdEx++ + m.CgroupDriver |= CgroupDriver(b&0x7F) << shift + if b < 0x80 { + break + } + } + default: + iNdEx = preIndex + skippy, err := skipApi(dAtA[iNdEx:]) + if err != nil { + return err + } + if (skippy < 0) || (iNdEx+skippy) < 0 { + return ErrInvalidLengthApi + } + if (iNdEx + skippy) > l { + return io.ErrUnexpectedEOF + } + iNdEx += skippy + } + } + + if iNdEx > l { + return io.ErrUnexpectedEOF + } + return nil +} func skipApi(dAtA []byte) (n int, err error) { l := len(dAtA) iNdEx := 0 diff --git a/contrib/tetragon-rthooks/vendor/k8s.io/cri-api/pkg/apis/runtime/v1/api.proto b/contrib/tetragon-rthooks/vendor/k8s.io/cri-api/pkg/apis/runtime/v1/api.proto index 3e20c42c609..9938c6a60a8 100644 --- a/contrib/tetragon-rthooks/vendor/k8s.io/cri-api/pkg/apis/runtime/v1/api.proto +++ b/contrib/tetragon-rthooks/vendor/k8s.io/cri-api/pkg/apis/runtime/v1/api.proto @@ -120,7 +120,7 @@ service RuntimeService { rpc CheckpointContainer(CheckpointContainerRequest) returns (CheckpointContainerResponse) {} // GetContainerEvents gets container events from the CRI runtime - rpc GetContainerEvents(GetEventsRequest) returns (stream ContainerEventResponse) {} + rpc GetContainerEvents(GetEventsRequest) returns (stream ContainerEventResponse) {} // ListMetricDescriptors gets the descriptors for the metrics that will be returned in ListPodSandboxMetrics. // This list should be static at startup: either the client and server restart together when @@ -131,6 +131,15 @@ service RuntimeService { // ListPodSandboxMetrics gets pod sandbox metrics from CRI Runtime rpc ListPodSandboxMetrics(ListPodSandboxMetricsRequest) returns (ListPodSandboxMetricsResponse) {} + + // RuntimeConfig returns configuration information of the runtime. + // A couple of notes: + // - The RuntimeConfigRequest object is not to be confused with the contents of UpdateRuntimeConfigRequest. + // The former is for having runtime tell Kubelet what to do, the latter vice versa. + // - It is the expectation of the Kubelet that these fields are static for the lifecycle of the Kubelet. + // The Kubelet will not re-request the RuntimeConfiguration after startup, and CRI implementations should + // avoid updating them without a full node reboot. + rpc RuntimeConfig(RuntimeConfigRequest) returns (RuntimeConfigResponse) {} } // ImageService defines the public APIs for managing images. @@ -199,7 +208,7 @@ message PortMapping { } enum MountPropagation { - // No mount propagation ("private" in Linux terminology). + // No mount propagation ("rprivate" in Linux terminology). PROPAGATION_PRIVATE = 0; // Mounts get propagated from the host to the container ("rslave" in Linux). PROPAGATION_HOST_TO_CONTAINER = 1; @@ -226,6 +235,24 @@ message Mount { repeated IDMapping uidMappings = 6; // GidMappings specifies the runtime GID mappings for the mount. repeated IDMapping gidMappings = 7; + // If set to true, the mount is made recursive read-only. + // In this CRI API, recursive_read_only is a plain true/false boolean, although its equivalent + // in the Kubernetes core API is a quaternary that can be nil, "Enabled", "IfPossible", or "Disabled". + // kubelet translates that quaternary value in the core API into a boolean in this CRI API. + // Remarks: + // - nil is just treated as false + // - when set to true, readonly must be explicitly set to true, and propagation must be PRIVATE (0). + // - (readonly == false && recursive_read_only == false) does not make the mount read-only. + bool recursive_read_only = 8; + // Mount an image reference (image ID, with or without digest), which is a + // special use case for image volume mounts. If this field is set, then + // host_path should be unset. All OCI mounts are per feature definition + // readonly. The kubelet does an PullImage RPC and evaluates the returned + // PullImageResponse.image_ref value, which is then set to the + // ImageSpec.image field. Runtimes are expected to mount the image as + // required. + // Introduced in the OCI Volume Source KEP: https://kep.k8s.io/4639 + ImageSpec image = 9; } // IDMapping describes host to container ID mappings for a pod sandbox. @@ -303,6 +330,20 @@ message NamespaceOption { UserNamespace userns_options = 5; } +// SupplementalGroupsPolicy defines how supplemental groups +// of the first container processes are calculated. +enum SupplementalGroupsPolicy { + // Merge means that the container's provided SupplementalGroups + // and FsGroup (specified in SecurityContext) will be merged with + // the primary user's groups as defined in the container image + // (in /etc/group). + Merge = 0; + // Strict means that the container's provided SupplementalGroups + // and FsGroup (specified in SecurityContext) will be used instead of + // any groups defined in the container image. + Strict = 1; +} + // Int64Value is the wrapper of int64. message Int64Value { // The value. @@ -327,13 +368,14 @@ message LinuxSandboxSecurityContext { Int64Value run_as_group = 8; // If set, the root filesystem of the sandbox is read-only. bool readonly_rootfs = 4; - // List of groups applied to the first process run in the sandbox, in - // addition to the sandbox's primary GID, and group memberships defined - // in the container image for the sandbox's primary UID of the container process. - // If the list is empty, no additional groups are added to any container. - // Note that group memberships defined in the container image for the sandbox's primary UID - // of the container process are still effective, even if they are not included in this list. + // List of groups applied to the first process run in each container. + // supplemental_groups_policy can control how groups will be calculated. repeated int64 supplemental_groups = 5; + // supplemental_groups_policy defines how supplemental groups of the first + // container processes are calculated. + // Valid values are "Merge" and "Strict". + // If not specified, "Merge" is used. + SupplementalGroupsPolicy supplemental_groups_policy = 11; // Indicates whether the sandbox will be asked to run a privileged // container. If a privileged container is to be executed within it, this // MUST be true. @@ -770,6 +812,13 @@ message ImageSpec { // ImageSpec Annotations can be used to help the runtime target specific // images in multi-arch images. map annotations = 2; + // The container image reference specified by the user (e.g. image[:tag] or digest). + // Only set if available within the RPC context. + string user_specified_image = 18; + // Runtime handler to use for pulling the image. + // If the runtime handler is unknown, the request should be rejected. + // An empty string would select the default runtime handler. + string runtime_handler = 19; } message KeyValue { @@ -880,13 +929,14 @@ message LinuxContainerSecurityContext { string run_as_username = 6; // If set, the root filesystem of the container is read-only. bool readonly_rootfs = 7; - // List of groups applied to the first process run in the container, in - // addition to the container's primary GID, and group memberships defined - // in the container image for the container's primary UID of the container process. - // If the list is empty, no additional groups are added to any container. - // Note that group memberships defined in the container image for the container's primary UID - // of the container process are still effective, even if they are not included in this list. + // List of groups applied to the first process run in each container. + // supplemental_groups_policy can control how groups will be calculated. repeated int64 supplemental_groups = 8; + // supplemental_groups_policy defines how supplemental groups of the first + // container processes are calculated. + // Valid values are "Merge" and "Strict". + // If not specified, "Merge" is used. + SupplementalGroupsPolicy supplemental_groups_policy = 17; // no_new_privs defines if the flag for no_new_privs should be set on the // container. bool no_new_privs = 11; @@ -925,6 +975,15 @@ message LinuxContainerConfig { LinuxContainerSecurityContext security_context = 2; } +message LinuxContainerUser { + // uid is the primary uid initially attached to the first process in the container + int64 uid = 1; + // gid is the primary gid initially attached to the first process in the container + int64 gid = 2; + // supplemental_groups are the supplemental groups initially attached to the first process in the container + repeated int64 supplemental_groups = 3; +} + // WindowsNamespaceOption provides options for Windows namespaces. message WindowsNamespaceOption { // Network namespace for this container/sandbox. @@ -1177,8 +1236,7 @@ message Container { ContainerMetadata metadata = 3; // Spec of the image. ImageSpec image = 4; - // Reference to the image in use. For most runtimes, this should be an - // image ID. + // Digested reference to the image in use. string image_ref = 5; // State of the container. ContainerState state = 6; @@ -1191,6 +1249,16 @@ message Container { // MUST be identical to that of the corresponding ContainerConfig used to // instantiate this Container. map annotations = 9; + // Reference to the unique identifier of the image, on the node, as + // returned in the image service apis. + // + // Note: The image_ref above has been historically used by container + // runtimes to reference images by digest. The image_ref has been also used + // in the kubelet image garbage collection, which does not work with + // digests at all. To separate and avoid possible misusage, we now + // introduce the image_id field, which should always refer to a unique + // image identifier on the node. + string image_id = 10; } message ListContainersResponse { @@ -1223,8 +1291,7 @@ message ContainerStatus { int32 exit_code = 7; // Spec of the image. ImageSpec image = 8; - // Reference to the image in use. For most runtimes, this should be an - // image ID + // Digested reference to the image in use. string image_ref = 9; // Brief CamelCase string explaining why container is in its current state. // Must be set to "OOMKilled" for containers terminated by cgroup-based Out-of-Memory killer. @@ -1245,6 +1312,16 @@ message ContainerStatus { string log_path = 15; // Resource limits configuration of the container. ContainerResources resources = 16; + // Reference to the unique identifier of the image, on the node, as + // returned in the image service apis. + // + // Note: The image_ref above has been historically used by container + // runtimes to reference images by digest. To separate and avoid possible + // misusage, we now introduce the image_id field, which should always refer + // to a unique image identifier on the node. + string image_id = 17; + // User identities initially attached to the container + ContainerUser user = 18; } message ContainerStatusResponse { @@ -1265,6 +1342,17 @@ message ContainerResources { WindowsContainerResources windows = 2; } +message ContainerUser { + // User identities initially attached to first process in the Linux container. + // Note that the actual running identity can be changed if the process has enough privilege to do so. + LinuxContainerUser linux = 1; + + // User identities initially attached to first process in the Windows container + // This is just reserved for future use. + // WindowsContainerUser windows = 2; +} + + message UpdateContainerResourcesRequest { // ID of the container to update. string container_id = 1; @@ -1512,6 +1600,35 @@ message StatusRequest { bool verbose = 1; } +// RuntimeHandlerFeatures is a set of features implemented by the runtime handler. +message RuntimeHandlerFeatures { + // recursive_read_only_mounts is set to true if the runtime handler supports + // recursive read-only mounts. + // For runc-compatible runtimes, availability of this feature can be detected by checking whether + // the Linux kernel version is >= 5.12, and, `runc features | jq .mountOptions` contains "rro". + bool recursive_read_only_mounts = 1; + + // user_namespaces is set to true if the runtime handler supports user namespaces as implemented + // in Kubernetes. This means support for both, user namespaces and idmap mounts. + bool user_namespaces = 2; +} + +message RuntimeHandler { + // Name must be unique in StatusResponse. + // An empty string denotes the default handler. + string name = 1; + // Supported features. + RuntimeHandlerFeatures features = 2; +} + +// RuntimeFeatures describes the set of features implemented by the CRI implementation. +// The features contained in the RuntimeFeatures should depend only on the cri implementation +// independent of runtime handlers. +message RuntimeFeatures { + // supplemental_groups_policy is set to true if the runtime supports SupplementalGroupsPolicy and ContainerUser. + bool supplemental_groups_policy = 1; +} + message StatusResponse { // Status of the Runtime. RuntimeStatus status = 1; @@ -1520,6 +1637,11 @@ message StatusResponse { // debug, e.g. plugins used by the container runtime. // It should only be returned non-empty when Verbose is true. map info = 2; + // Runtime handlers. + repeated RuntimeHandler runtime_handlers = 3; + // features describes the set of features implemented by the CRI implementation. + // This field is supposed to propagate to NodeFeatures in Kubernetes API. + RuntimeFeatures features = 4; } message ImageFsInfoRequest {} @@ -1567,6 +1689,11 @@ message WindowsFilesystemUsage { message ImageFsInfoResponse { // Information of image filesystem(s). repeated FilesystemUsage image_filesystems = 1; + // Information of container filesystem(s). + // This is an optional field, may be used for example if container and image + // storage are separated. + // Default will be to return this as empty. + repeated FilesystemUsage container_filesystems = 2; } message ContainerStatsRequest{ @@ -1627,6 +1754,8 @@ message ContainerStats { MemoryUsage memory = 3; // Usage of the writable layer. FilesystemUsage writable_layer = 4; + // Swap usage gathered from the container. + SwapUsage swap = 5; } // WindowsContainerStats provides the resource usage statistics for a container specific for Windows @@ -1681,16 +1810,27 @@ message MemoryUsage { UInt64Value major_page_faults = 7; } +message SwapUsage { + // Timestamp in nanoseconds at which the information were collected. Must be > 0. + int64 timestamp = 1; + // Available swap for use. This is defined as the swap limit - swapUsageBytes. + UInt64Value swap_available_bytes = 2; + // Total memory in use. This includes all memory regardless of when it was accessed. + UInt64Value swap_usage_bytes = 3; +} + // WindowsMemoryUsage provides the memory usage information specific to Windows message WindowsMemoryUsage { // Timestamp in nanoseconds at which the information were collected. Must be > 0. int64 timestamp = 1; // The amount of working set memory in bytes. UInt64Value working_set_bytes = 2; - // Available memory for use. This is defined as the memory limit - workingSetBytes. + // Available memory for use. This is defined as the memory limit - commit_memory_bytes. UInt64Value available_bytes = 3; // Cumulative number of page faults. UInt64Value page_faults = 4; + // Total commit memory in use. Commit memory is total of physical and virtual memory in use. + UInt64Value commit_memory_bytes = 5; } message ReopenContainerLogRequest { @@ -1801,3 +1941,29 @@ enum MetricType { COUNTER = 0; GAUGE = 1; } + +message RuntimeConfigRequest {} + +message RuntimeConfigResponse { + // Configuration information for Linux-based runtimes. This field contains + // global runtime configuration options that are not specific to runtime + // handlers. + LinuxRuntimeConfiguration linux = 1; +} + +message LinuxRuntimeConfiguration { + // Cgroup driver to use + // Note: this field should not change for the lifecycle of the Kubelet, + // or while there are running containers. + // The Kubelet will not re-request this after startup, and will construct the cgroup + // hierarchy assuming it is static. + // If the runtime wishes to change this value, it must be accompanied by removal of + // all pods, and a restart of the Kubelet. The easiest way to do this is with a full node reboot. + CgroupDriver cgroup_driver = 1; +} + +enum CgroupDriver { + SYSTEMD = 0; + CGROUPFS = 1; +} + diff --git a/contrib/tetragon-rthooks/vendor/modules.txt b/contrib/tetragon-rthooks/vendor/modules.txt index f414bd4daea..bfb79f12f26 100644 --- a/contrib/tetragon-rthooks/vendor/modules.txt +++ b/contrib/tetragon-rthooks/vendor/modules.txt @@ -16,9 +16,8 @@ github.com/cilium/lumberjack/v2 # github.com/cilium/tetragon/api v0.0.0-00010101000000-000000000000 => ../../api ## explicit; go 1.23.0 github.com/cilium/tetragon/api/v1/tetragon -# github.com/containerd/containerd v1.7.23 +# github.com/containerd/containerd v1.7.18 ## explicit; go 1.21 -github.com/containerd/containerd/errdefs github.com/containerd/containerd/events github.com/containerd/containerd/events/exchange github.com/containerd/containerd/filters @@ -26,7 +25,7 @@ github.com/containerd/containerd/identifiers github.com/containerd/containerd/namespaces github.com/containerd/containerd/plugin github.com/containerd/containerd/services/server/config -# github.com/containerd/errdefs v0.3.0 +# github.com/containerd/errdefs v1.0.0 ## explicit; go 1.20 github.com/containerd/errdefs # github.com/containerd/log v0.1.0 @@ -42,7 +41,7 @@ github.com/containerd/nri/pkg/stub # github.com/containerd/ttrpc v1.2.6-0.20240827082320-b5cd6e4b3287 ## explicit; go 1.19 github.com/containerd/ttrpc -# github.com/containerd/typeurl/v2 v2.2.0 +# github.com/containerd/typeurl/v2 v2.2.2 ## explicit; go 1.21 github.com/containerd/typeurl/v2 # github.com/containers/common v0.61.0 @@ -94,8 +93,8 @@ github.com/google/cel-go/common/types/traits github.com/google/cel-go/interpreter github.com/google/cel-go/parser github.com/google/cel-go/parser/gen -# github.com/kr/pretty v0.3.1 -## explicit; go 1.12 +# github.com/kr/text v0.2.0 +## explicit # github.com/moby/sys/mountinfo v0.7.2 ## explicit; go 1.17 github.com/moby/sys/mountinfo @@ -128,8 +127,8 @@ github.com/pelletier/go-toml # github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 ## explicit github.com/pmezard/go-difflib/difflib -# github.com/rogpeppe/go-internal v1.11.0 -## explicit; go 1.19 +# github.com/prometheus/procfs v0.15.1 +## explicit; go 1.20 # github.com/sirupsen/logrus v1.9.3 ## explicit; go 1.13 github.com/sirupsen/logrus @@ -162,7 +161,7 @@ golang.org/x/text/secure/bidirule golang.org/x/text/transform golang.org/x/text/unicode/bidi golang.org/x/text/unicode/norm -# google.golang.org/genproto/googleapis/api v0.0.0-20240903143218-8af14fe29dc1 +# google.golang.org/genproto/googleapis/api v0.0.0-20241007155032-5fefd90f89a9 ## explicit; go 1.21 google.golang.org/genproto/googleapis/api/expr/v1alpha1 # google.golang.org/genproto/googleapis/rpc v0.0.0-20241021214115-324edc3d5d38 @@ -273,7 +272,7 @@ google.golang.org/protobuf/types/known/wrapperspb # gopkg.in/yaml.v3 v3.0.1 ## explicit gopkg.in/yaml.v3 -# k8s.io/cri-api v0.27.1 -## explicit; go 1.20 +# k8s.io/cri-api v0.31.2 +## explicit; go 1.22.0 k8s.io/cri-api/pkg/apis/runtime/v1 # github.com/cilium/tetragon/api => ../../api