pax_global_header00006660000000000000000000000064147246511510014520gustar00rootroot0000000000000052 comment=67fcf83dd3a3efb916655f581980d664fe2ff771 kubernetes-cri-api-4685890/000077500000000000000000000000001472465115100154225ustar00rootroot00000000000000kubernetes-cri-api-4685890/.github/000077500000000000000000000000001472465115100167625ustar00rootroot00000000000000kubernetes-cri-api-4685890/.github/PULL_REQUEST_TEMPLATE.md000066400000000000000000000002251472465115100225620ustar00rootroot00000000000000Sorry, we do not accept changes directly against this repository. Please see CONTRIBUTING.md for information on where and how to contribute instead. kubernetes-cri-api-4685890/CONTRIBUTING.md000066400000000000000000000013411472465115100176520ustar00rootroot00000000000000# Contributing guidelines Do not open pull requests directly against this repository, they will be ignored. Instead, please open pull requests against [kubernetes/kubernetes](https://git.k8s.io/kubernetes/). Please follow the same [contributing guide](https://git.k8s.io/kubernetes/CONTRIBUTING.md) you would follow for any other pull request made to kubernetes/kubernetes. This repository is published from [kubernetes/kubernetes/staging/src/k8s.io/cri-api](https://git.k8s.io/kubernetes/staging/src/k8s.io/cri-api) by the [kubernetes publishing-bot](https://git.k8s.io/publishing-bot). Please see [Staging Directory and Publishing](https://git.k8s.io/community/contributors/devel/sig-architecture/staging.md) for more information. kubernetes-cri-api-4685890/LICENSE000066400000000000000000000261351472465115100164360ustar00rootroot00000000000000 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "{}" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright {yyyy} {name of copyright owner} 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. kubernetes-cri-api-4685890/OWNERS000066400000000000000000000006221472465115100163620ustar00rootroot00000000000000# See the OWNERS docs at https://go.k8s.io/owners # Disable inheritance as this is owned by sig-node (should mirror same contents as pkg/kubelet/OWNERS) options: no_parent_owners: true approvers: - dims - feiskyer - sig-node-approvers - api-approvers - sig-node-cri-approvers reviewers: - sig-node-reviewers - dims labels: - sig/node - area/kubelet emeritus_approvers: - resouer kubernetes-cri-api-4685890/README.md000066400000000000000000000350241472465115100167050ustar00rootroot00000000000000## Purpose This repository contains the definitions for the Container Runtime Interface (CRI). CRI is a plugin interface which enables kubelet to use a wide variety of container runtimes, without the need to recompile. CRI consists of a protocol buffers and gRPC API. Read more about CRI API at [kubernetes docs](https://kubernetes.io/docs/concepts/architecture/cri/). The repository [kubernetes/cri-api](https://github.com/kubernetes/cri-api) is a mirror of https://github.com/kubernetes/kubernetes/tree/master/staging/src/k8s.io/cri-api. Please do **not** file issues or submit PRs against the [kubernetes/cri-api](https://github.com/kubernetes/cri-api) repository as it is readonly, all development is done in [kubernetes/kubernetes](https://github.com/kubernetes/kubernetes). The CRI API is defined in [kubernetes/kubernetes](https://github.com/kubernetes/kubernetes) repository and is **only** intended to be used for kubelet to container runtime interactions, or for node-level troubleshooting using a tool such as `crictl`. It is **not** a common purpose container runtime API for general use, and is intended to be Kubernetes-centric. We try to avoid it, but there may be logic within a container runtime that optimizes for the order or specific parameters of call(s) that the kubelet makes. ## Version skew policy On a single Node there may be installed multiple components implementing different versions of CRI API. For example, on a single node there might be: - _Kubelet_ may call into _Container Runtime_ (e.g. [containerd](https://containerd.io)) and _Image Service Proxy_ (e.g. [stargz-snapshotter](https://github.com/containerd/stargz-snapshotter)). _Container Runtime_ may be versioned with the OS Image, _Kubelet_ is installed by system administrator and _Image Service proxy_ is versioned by the third party vendor. - _Image Service Proxy_ calls into _Container Runtime_. - _CRI tools_ (e.g. [crictl](https://kubernetes.io/docs/tasks/debug/debug-cluster/crictl/)) may be installed by end user to troubleshoot, same as a third party daemonsets. All of them are used to call into the _Container Runtime_ to collect container information. So on a single node it may happen that _Container Runtime_ is serving a newer version'd kubelet and older versioned crictl. This is a supported scenario within the version skew policy. ### Version Skew Policy for CRI API CRI API has two versions: - Major semantic version (known versions are `v1alpha2` ([removed in 1.26](https://kubernetes.io/blog/2022/12/09/kubernetes-v1-26-release/#cri-v1alpha2-removed)), `v1`). - Kubernetes version (for example: `@1.23`). Note, the `cri-api` Golang library is versioned as `0.23` as it doesn't guarantee Go types backward compatibility. Major semantic version (e.g. `v1`) is used to introduce breaking changes and major new features that are incompatible with the current API. Kubernetes version is used to indicate a specific feature set implemented on top of the major semantic version. All changes made without the change of a major semantic version API must be backward and forward compatible. - _Kubelet_ must work with the older _Container Runtime_ if it implements the same semantic version of CRI API (e.g. `v1`) of up to three Kubernetes minor versions back. New features implemented in CRI API must be gracefully degraded. For example, _Kubelet_ of version 1.26 must work with _Container Runtime_ implementing `k8s.io/cri-api@v0.23.0`+. - _Kubelet_ must work with _Container Runtime_ if it implements the same semantic version of CRI API (e.g. `v1`) of up to three minor versions up. New features implemented in CRI API must not change behavior of old method calls and response values. For example, _Kubelet_ of version 1.22 must work with _Container Runtime_ implementing `k8s.io/cri-api@v0.25.5`. ## Versioning This library contains go classes generated from the CRI API protocol buffers and gRPC API. The library versioned as `0.XX` as Kubernetes doesn't provide any guarantees on backward compatibility of Go wrappers between versions. However CRI API itself (protocol buffers and gRPC API) is marked as stable `v1` version and it is backward compatible between versions. Versions like `v0..` (e.g. `v0.25.5`) are considered stable. It is discouraged to introduce CRI API changes in patch releases and recommended to use versions like `v0..0`. All alpha and beta versions (e.g. `k8s.io/cri-api@v0.26.0-beta.0`) should be backward and forward compatible. ## Feature development Some features development requires changes in CRI API and corresponding changes in _Container Runtime_. Coordinating between Kubernetes branches and release versions and _Container Runtime_ versions is not always trivial. The recommended feature development flow is following: - Review proposed CRI API changes during the KEP review stage. Some field names and types may not be spelled out exactly at this stage. - Locally implement a prototype that implement changes in both - Kubernetes and Container Runtime. - Submit a Pull Request for Kubernetes implementing CRI API changes alongside the feature code. Feature must be developed to degrade gracefully when used with older Container Runtime according to the Version Skew policy. - Once PR is merged, wait for the next Kubernetes release tag being produced. Find the corresponding CRI API tag (e.g. `k8s.io/cri-api@v0.26.0-beta.0`). - This tag can be used to implement the feature in Container Runtime. It is recommended to switch to the stable tag like (`k8s.io/cri-api@v0.26.0`) once available. ## Change history Here is the change history of the Container Runtime Interface protocol: ### v1.20 `git diff v1.19.0 v1.20.0 -- staging/src/k8s.io/cri-api/pkg/apis/runtime/v1/api.proto` - CRI [v1 introduced](https://github.com/kubernetes/kubernetes/pull/96387) ### v1.21 `git diff v1.20.0 v1.21.0 -- staging/src/k8s.io/cri-api/pkg/apis/runtime/v1/api.proto` No changes ### v1.22 `git diff v1.21.0 v1.22.0 -- staging/src/k8s.io/cri-api/pkg/apis/runtime/v1/api.proto` - [Windows host process support](https://github.com/kubernetes/kubernetes/pull/99576) - `PodSandboxConfig` has `windows` field of type `WindowsPodSandboxConfig` - New type `WindowsPodSandboxConfig` introduced - New type `WindowsSandboxSecurityContext` introduced - The type `WindowsContainerSecurityContext` has a new `host_process` boolean field - [Feature: add unified on CRI to support cgroup v2](https://github.com/kubernetes/kubernetes/pull/102578) - The type `LinuxContainerResources` has a new field `unified` which is a map of strings - [Alpha node swap support](https://github.com/kubernetes/kubernetes/pull/102823) - The type `LinuxContainerResources` has a new `memory_swap_limit_in_bytes` int64 field ### v1.23 `git diff v1.22.0 v1.23.0 -- staging/src/k8s.io/cri-api/pkg/apis/runtime/v1/api.proto` - [CRI: add fields for pod level stats to satisfy the /stats/summary API](https://github.com/kubernetes/kubernetes/pull/102789) - New functions `PodSandboxStats`, `ListPodSandboxStats` with the corresponding types of request and response objects are introduced - [pass sandbox resource requirements over CRI](https://github.com/kubernetes/kubernetes/pull/104886) - New fields on `LinuxPodSandboxConfig`: `overhead` and `resources` of type `LinuxContainerResources`. - [prevents garbage collection from removing pinned images](https://github.com/kubernetes/kubernetes/pull/103299) - The type `Image` has a new boolean field `pinned` ### v1.24 `git diff v1.23.0 v1.24.0 -- staging/src/k8s.io/cri-api/pkg/apis/runtime/v1/api.proto` - [Update CRI-API Capabilities to include a field that allows us to set ambient capabilities](https://github.com/kubernetes/kubernetes/pull/104620) - The type `Capability` has a new string field `add_ambient_capabilities` - [CRI-API - Add rootfs size to WindowsContainerResources](https://github.com/kubernetes/kubernetes/pull/108894) - The type `WindowsContainerResources` has a new int64 field `rootfs_size_in_bytes` ### v1.25 `git diff v1.24.0 v1.25.0 -- staging/src/k8s.io/cri-api/pkg/apis/runtime/v1/api.proto` - [kubelet: add CRI definitions for user namespaces](https://github.com/kubernetes/kubernetes/pull/110535) - The new type `UserNamespace` introduced to represent user namespaces id mapping - The type `NamespaceOption` has a new field `userns_options` of type `UserNamespace` - [Minimal checkpointing support](https://github.com/kubernetes/kubernetes/pull/104907) - The new method `CheckpointContainer` introduced with the corresponding request and response types - [Update CRI API to support Evented PLEG](https://github.com/kubernetes/kubernetes/pull/111642) - The new streaming method `GetContainerEvents` is introduced with the corresponding request and response types - [CRI changes to support in-place pod resize](https://github.com/kubernetes/kubernetes/pull/111645) - The new type `ContainerResources` is introduced - The type `ContainerStatus` has a new field `resources` of type `ContainerResources` - The semantic of `UpdateContainerResources` updated. The method must be implemented as synchronous and return error on failure ### v1.26 `git diff v1.25.0 v1.26.0 -- staging/src/k8s.io/cri-api/pkg/apis/runtime/v1/api.proto` - [CRI: Add Windows Podsandbox Stats](https://github.com/kubernetes/kubernetes/pull/110754) - Added fields to the type `WindowsPodSandboxStats` expressing stats required to be collected from windows pods. - [Windows hostnetwork alpha](https://github.com/kubernetes/kubernetes/pull/112961) - New type `WindowsNamespaceOption` introduced - The type `WindowsSandboxSecurityContext` has a new field `namespace_options` of type `WindowsNamespaceOption` - [Improve the API description of `PodSecurityContext.SupplementalGroups` to clarify its unfamiliar behavior](https://github.com/kubernetes/kubernetes/pull/113047) - Clarified the expected behavior of `SupplementalGroups` field of `PodSecurityContext` - [Add Support for Evented PLEG](https://github.com/kubernetes/kubernetes/pull/111384) - The type `ContainerEventResponse` updated: the field `pod_sandbox_metadata` removed and fields `pod_sandbox_status` and `containers_statuses` added. - The type `PodSandboxStatusResponse` has a new fields `containers_statuses` and `timestamp` ### v1.27 `git diff v1.26.0 v1.27.0 -- staging/src/k8s.io/cri-api/pkg/apis/runtime/v1/api.proto` - [CRI: Add CDI device info for containers](https://github.com/kubernetes/kubernetes/pull/115891/) - New type `CDIDevice` was introduced and added to container config - [Add mappings for volumes](https://github.com/kubernetes/kubernetes/pull/116377) - Added new fields to the type `Mount` expressing runtime UID/GID mappings for the mount. ### v1.28 `git diff v1.27.0 v1.28.0 -- staging/src/k8s.io/cri-api/pkg/apis/runtime/v1/api.proto` - [cri-api: fix comment lines about PROPAGATION_PRIVATE](https://github.com/kubernetes/kubernetes/pull/115704) - Fixed comment lines about PROPAGATION_PRIVATE - [Add user specified image to CRI ContainerConfig](https://github.com/kubernetes/kubernetes/pull/118652) - Added the `user_specified_image` field to type `ImageSpec` - [kubelet: get cgroup driver config from CRI ](https://github.com/kubernetes/kubernetes/pull/118770) - Added rpc for querying runtime configuration - Added cavieats about cgroup driver field - [Add swap to stats to Summary API and Prometheus endpoints (/stats/summary and /metrics/resource)](https://github.com/kubernetes/kubernetes/pull/118865) - Added `SwapUsage` type - Added `SwapUsage` field to `ContainerStats` type - [Expose commit memory used in WindowsMemoryUsage struct](https://github.com/kubernetes/kubernetes/pull/119238) - Added the `commit_memory_bytes` field to type `WindowsMemoryUsage` ### v1.29 `git diff v1.28.0 v1.29.0 -- staging/src/k8s.io/cri-api/pkg/apis/runtime/v1/api.proto` - [Add runtime handler field to ImageSpec struct](https://github.com/kubernetes/kubernetes/pull/121121) - Added `runtime_handler` field to type `ImageSpec` - [Add container filesystem to the ImageFsInfoResponse](https://github.com/kubernetes/kubernetes/pull/120914) - Added `container_filesystems` field to type `ImageFsInfoResponse` ### v1.30 `git diff v1.29.0 v1.30.0 -- staging/src/k8s.io/cri-api/pkg/apis/runtime/v1/api.proto` - [Recursive Read-only (RRO) mounts](https://github.com/kubernetes/kubernetes/pull/123272) - Added RuntimeHandler and RuntimeHandlerFeatures type - Added `recursive_read_only` field to type `Mount` - Added `runtime_handlers` field to type `StatusResponse` - [Add user_namespaces field to RuntimeHandlerFeatures](https://github.com/kubernetes/kubernetes/pull/123356) - Added `user_namespaces` field to type `RuntimeHandlerFeatures` - [Add image_id to CRI Container message](https://github.com/kubernetes/kubernetes/pull/123508) - Added `image_id` field to type `Container` - [Add image_id to CRI ContainerStatus message](https://github.com/kubernetes/kubernetes/pull/123583) - Added `image_id` field to type `ContainerStatus` ### v1.31 `git diff v1.30.0 v1.31.0 -- staging/src/k8s.io/cri-api/pkg/apis/runtime/v1/api.proto` - [KEP-3619: Add NodeStatus.Features.SupplementalGroupsPolicy API and e2e](https://github.com/kubernetes/kubernetes/pull/125470) - Added `features` field to the type `StatusResponse` for the runtime to kubelet handshake on what features are supported - [KEP-3619: Fine-grained SupplementalGroups control](https://github.com/kubernetes/kubernetes/pull/117842) - Added `supplemental_groups_policy` field to types `LinuxContainerSecurityContext` and `LinuxSandboxSecurityContext` - Added `user` field to the type `ContainerStatus` to represent actual user for the container - [[KEP-4639] Add OCI VolumeSource CRI API](https://github.com/kubernetes/kubernetes/pull/125659) - Added `image` field to the type `Mount` to represent the OCI VolumeSource ## Community, discussion, contribution, and support Learn how to engage with the Kubernetes community on the [community page](http://kubernetes.io/community/). You can reach the maintainers of this repository at: - Slack: #sig-node (on https://kubernetes.slack.com -- get an invite at [slack.kubernetes.io](https://slack.kubernetes.io)) - Mailing List: https://groups.google.com/forum/#!forum/kubernetes-sig-node ### Code of Conduct Participation in the Kubernetes community is governed by the [Kubernetes Code of Conduct](code-of-conduct.md). ### Contribution Guidelines See [CONTRIBUTING.md](CONTRIBUTING.md) for more information. Please note that [kubernetes/cri-api](https://github.com/kubernetes/cri-api) is a readonly mirror repository, all development is done at [kubernetes/kubernetes](https://github.com/kubernetes/kubernetes). kubernetes-cri-api-4685890/SECURITY_CONTACTS000066400000000000000000000011011472465115100201030ustar00rootroot00000000000000# Defined below are the security contacts for this repo. # # They are the contact point for the Product Security Committee to reach out # to for triaging and handling of incoming issues. # # The below names agree to abide by the # [Embargo Policy](https://git.k8s.io/security/private-distributors-list.md#embargo-policy) # and will be removed and replaced if they violate that agreement. # # DO NOT REPORT SECURITY VULNERABILITIES DIRECTLY TO THESE NAMES, FOLLOW THE # INSTRUCTIONS AT https://kubernetes.io/security/ tallclair yujuhong dims cjcullen joelsmith liggitt philips kubernetes-cri-api-4685890/code-of-conduct.md000066400000000000000000000002241472465115100207130ustar00rootroot00000000000000# Kubernetes Community Code of Conduct Please refer to our [Kubernetes Community Code of Conduct](https://git.k8s.io/community/code-of-conduct.md) kubernetes-cri-api-4685890/doc.go000066400000000000000000000011451472465115100165170ustar00rootroot00000000000000/* Copyright 2021 The Kubernetes 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 criapi // import "k8s.io/cri-api" kubernetes-cri-api-4685890/go.mod000066400000000000000000000015411472465115100165310ustar00rootroot00000000000000// This is a generated file. Do not edit directly. module k8s.io/cri-api go 1.23.0 godebug default=go1.23 godebug winsymlink=0 require ( github.com/gogo/protobuf v1.3.2 github.com/stretchr/testify v1.9.0 google.golang.org/grpc v1.65.0 ) require ( github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/kr/pretty v0.3.1 // indirect github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 // indirect github.com/rogpeppe/go-internal v1.12.0 // indirect golang.org/x/net v0.30.0 // indirect golang.org/x/sys v0.26.0 // indirect golang.org/x/text v0.19.0 // indirect google.golang.org/genproto/googleapis/rpc v0.0.0-20240826202546-f6391c0de4c7 // indirect google.golang.org/protobuf v1.35.1 // indirect gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect gopkg.in/yaml.v3 v3.0.1 // indirect ) kubernetes-cri-api-4685890/go.sum000066400000000000000000000145221472465115100165610ustar00rootroot00000000000000github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/gogo/protobuf v1.3.2 h1:Ov1cvc58UF3b5XjBnZv7+opcTcQFZebYjWzi34vdm4Q= github.com/gogo/protobuf v1.3.2/go.mod h1:P1XiOD3dCwIKUDQYPy72D8LYyHL2YPYrpS2s69NZV8Q= github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= github.com/kisielk/errcheck v1.5.0/go.mod h1:pFxgyoBC7bSaBwPgfKdkLd5X25qrDl4LWUI2bnpBCr8= github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck= github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA= 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/rogpeppe/go-internal v1.9.0/go.mod h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs= 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/stretchr/testify v1.9.0 h1:HtqpIVDClZ4nwg75+f6Lvsy/wHu+3BoSGCbBAcpTsTg= github.com/stretchr/testify v1.9.0/go.mod h1:r2ic/lqez/lEtzL7wO/rwa5dbSLXVDPFyf8C91i36aY= github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU= golang.org/x/net v0.30.0 h1:AcW1SDZMkb8IpzCdQUaIq2sP4sZ4zw+55h6ynffypl4= golang.org/x/net v0.30.0/go.mod h1:2wGyMJ5iFasEhkwi13ChkO/t1ECNC4X4eBKkVFyYFlU= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.26.0 h1:KHjCJyddX0LoSTb3J+vWpupP9p0oznkqVk/IfjymZbo= golang.org/x/sys v0.26.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.19.0 h1:kTxAhCbGbxhK0IwgSKiMO5awPoDQ0RpfiVYBfK860YM= golang.org/x/text v0.19.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY= golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo= golang.org/x/tools v0.0.0-20200619180055-7c47624df98f/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE= golang.org/x/tools v0.0.0-20210106214847-113979e3529a/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA= golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= 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/rpc v0.0.0-20240826202546-f6391c0de4c7 h1:2035KHhUv+EpyB+hWgJnaWKJOdX1E95w2S8Rr4uWKTs= google.golang.org/genproto/googleapis/rpc v0.0.0-20240826202546-f6391c0de4c7/go.mod h1:UqMtugtsSgubUsoxbuAoiCXvqvErP7Gf0so0mK9tHxU= google.golang.org/grpc v1.65.0 h1:bs/cUb4lp1G5iImFFd3u5ixQzweKizoZJAwBNLR42lc= google.golang.org/grpc v1.65.0/go.mod h1:WgYC2ypjlB0EiQi6wdKixMqukr6lBc0Vo+oOgjrM5ZQ= google.golang.org/protobuf v1.35.1 h1:m3LfL6/Ca+fqnjnlqQXNpFPABW1UD7mjh8KO2mKFytA= google.golang.org/protobuf v1.35.1/go.mod h1:9fA7Ob0pmnwhb644+1+CVWFRbNajQ6iRojtC/QF5bRE= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= kubernetes-cri-api-4685890/pkg/000077500000000000000000000000001472465115100162035ustar00rootroot00000000000000kubernetes-cri-api-4685890/pkg/apis/000077500000000000000000000000001472465115100171375ustar00rootroot00000000000000kubernetes-cri-api-4685890/pkg/apis/runtime/000077500000000000000000000000001472465115100206225ustar00rootroot00000000000000kubernetes-cri-api-4685890/pkg/apis/runtime/v1/000077500000000000000000000000001472465115100211505ustar00rootroot00000000000000kubernetes-cri-api-4685890/pkg/apis/runtime/v1/api.pb.go000066400000000000000000046605001472465115100226630ustar00rootroot00000000000000/* Copyright The Kubernetes 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. */ // Code generated by protoc-gen-gogo. DO NOT EDIT. // source: api.proto package v1 import ( context "context" fmt "fmt" _ "github.com/gogo/protobuf/gogoproto" proto "github.com/gogo/protobuf/proto" github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys" grpc "google.golang.org/grpc" codes "google.golang.org/grpc/codes" status "google.golang.org/grpc/status" io "io" math "math" math_bits "math/bits" reflect "reflect" strings "strings" ) // Reference imports to suppress errors if they are not otherwise used. var _ = proto.Marshal var _ = fmt.Errorf var _ = math.Inf // This is a compile-time assertion to ensure that this generated file // is compatible with the proto package it is being compiled against. // A compilation error at this line likely means your copy of the // proto package needs to be updated. const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package type Protocol int32 const ( Protocol_TCP Protocol = 0 Protocol_UDP Protocol = 1 Protocol_SCTP Protocol = 2 ) var Protocol_name = map[int32]string{ 0: "TCP", 1: "UDP", 2: "SCTP", } var Protocol_value = map[string]int32{ "TCP": 0, "UDP": 1, "SCTP": 2, } func (x Protocol) String() string { return proto.EnumName(Protocol_name, int32(x)) } func (Protocol) EnumDescriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{0} } type MountPropagation int32 const ( // 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 // Mounts get propagated from the host to the container and from the // container to the host ("rshared" in Linux). MountPropagation_PROPAGATION_BIDIRECTIONAL MountPropagation = 2 ) var MountPropagation_name = map[int32]string{ 0: "PROPAGATION_PRIVATE", 1: "PROPAGATION_HOST_TO_CONTAINER", 2: "PROPAGATION_BIDIRECTIONAL", } var MountPropagation_value = map[string]int32{ "PROPAGATION_PRIVATE": 0, "PROPAGATION_HOST_TO_CONTAINER": 1, "PROPAGATION_BIDIRECTIONAL": 2, } func (x MountPropagation) String() string { return proto.EnumName(MountPropagation_name, int32(x)) } func (MountPropagation) EnumDescriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{1} } // A NamespaceMode describes the intended namespace configuration for each // of the namespaces (Network, PID, IPC) in NamespaceOption. Runtimes should // map these modes as appropriate for the technology underlying the runtime. type NamespaceMode int32 const ( // A POD namespace is common to all containers in a pod. // For example, a container with a PID namespace of POD expects to view // all of the processes in all of the containers in the pod. NamespaceMode_POD NamespaceMode = 0 // A CONTAINER namespace is restricted to a single container. // For example, a container with a PID namespace of CONTAINER expects to // view only the processes in that container. NamespaceMode_CONTAINER NamespaceMode = 1 // A NODE namespace is the namespace of the Kubernetes node. // For example, a container with a PID namespace of NODE expects to view // all of the processes on the host running the kubelet. NamespaceMode_NODE NamespaceMode = 2 // TARGET targets the namespace of another container. When this is specified, // a target_id must be specified in NamespaceOption and refer to a container // previously created with NamespaceMode CONTAINER. This containers namespace // will be made to match that of container target_id. // For example, a container with a PID namespace of TARGET expects to view // all of the processes that container target_id can view. NamespaceMode_TARGET NamespaceMode = 3 ) var NamespaceMode_name = map[int32]string{ 0: "POD", 1: "CONTAINER", 2: "NODE", 3: "TARGET", } var NamespaceMode_value = map[string]int32{ "POD": 0, "CONTAINER": 1, "NODE": 2, "TARGET": 3, } func (x NamespaceMode) String() string { return proto.EnumName(NamespaceMode_name, int32(x)) } 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 ( PodSandboxState_SANDBOX_READY PodSandboxState = 0 PodSandboxState_SANDBOX_NOTREADY PodSandboxState = 1 ) var PodSandboxState_name = map[int32]string{ 0: "SANDBOX_READY", 1: "SANDBOX_NOTREADY", } var PodSandboxState_value = map[string]int32{ "SANDBOX_READY": 0, "SANDBOX_NOTREADY": 1, } func (x PodSandboxState) String() string { return proto.EnumName(PodSandboxState_name, int32(x)) } func (PodSandboxState) EnumDescriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{4} } type ContainerState int32 const ( ContainerState_CONTAINER_CREATED ContainerState = 0 ContainerState_CONTAINER_RUNNING ContainerState = 1 ContainerState_CONTAINER_EXITED ContainerState = 2 ContainerState_CONTAINER_UNKNOWN ContainerState = 3 ) var ContainerState_name = map[int32]string{ 0: "CONTAINER_CREATED", 1: "CONTAINER_RUNNING", 2: "CONTAINER_EXITED", 3: "CONTAINER_UNKNOWN", } var ContainerState_value = map[string]int32{ "CONTAINER_CREATED": 0, "CONTAINER_RUNNING": 1, "CONTAINER_EXITED": 2, "CONTAINER_UNKNOWN": 3, } func (x ContainerState) String() string { return proto.EnumName(ContainerState_name, int32(x)) } func (ContainerState) EnumDescriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{5} } type ContainerEventType int32 const ( // Container created ContainerEventType_CONTAINER_CREATED_EVENT ContainerEventType = 0 // Container started ContainerEventType_CONTAINER_STARTED_EVENT ContainerEventType = 1 // Container stopped ContainerEventType_CONTAINER_STOPPED_EVENT ContainerEventType = 2 // Container deleted ContainerEventType_CONTAINER_DELETED_EVENT ContainerEventType = 3 ) var ContainerEventType_name = map[int32]string{ 0: "CONTAINER_CREATED_EVENT", 1: "CONTAINER_STARTED_EVENT", 2: "CONTAINER_STOPPED_EVENT", 3: "CONTAINER_DELETED_EVENT", } var ContainerEventType_value = map[string]int32{ "CONTAINER_CREATED_EVENT": 0, "CONTAINER_STARTED_EVENT": 1, "CONTAINER_STOPPED_EVENT": 2, "CONTAINER_DELETED_EVENT": 3, } func (x ContainerEventType) String() string { return proto.EnumName(ContainerEventType_name, int32(x)) } func (ContainerEventType) EnumDescriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{6} } type MetricType int32 const ( MetricType_COUNTER MetricType = 0 MetricType_GAUGE MetricType = 1 ) var MetricType_name = map[int32]string{ 0: "COUNTER", 1: "GAUGE", } var MetricType_value = map[string]int32{ "COUNTER": 0, "GAUGE": 1, } func (x MetricType) String() string { return proto.EnumName(MetricType_name, int32(x)) } func (MetricType) EnumDescriptor() ([]byte, []int) { 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. type SecurityProfile_ProfileType int32 const ( // The container runtime default profile should be used. SecurityProfile_RuntimeDefault SecurityProfile_ProfileType = 0 // Disable the feature for the sandbox or the container. SecurityProfile_Unconfined SecurityProfile_ProfileType = 1 // A pre-defined profile on the node should be used. SecurityProfile_Localhost SecurityProfile_ProfileType = 2 ) var SecurityProfile_ProfileType_name = map[int32]string{ 0: "RuntimeDefault", 1: "Unconfined", 2: "Localhost", } var SecurityProfile_ProfileType_value = map[string]int32{ "RuntimeDefault": 0, "Unconfined": 1, "Localhost": 2, } func (x SecurityProfile_ProfileType) String() string { return proto.EnumName(SecurityProfile_ProfileType_name, int32(x)) } func (SecurityProfile_ProfileType) EnumDescriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{10, 0} } type VersionRequest struct { // Version of the kubelet runtime API. Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *VersionRequest) Reset() { *m = VersionRequest{} } func (*VersionRequest) ProtoMessage() {} func (*VersionRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{0} } func (m *VersionRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *VersionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_VersionRequest.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 *VersionRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_VersionRequest.Merge(m, src) } func (m *VersionRequest) XXX_Size() int { return m.Size() } func (m *VersionRequest) XXX_DiscardUnknown() { xxx_messageInfo_VersionRequest.DiscardUnknown(m) } var xxx_messageInfo_VersionRequest proto.InternalMessageInfo func (m *VersionRequest) GetVersion() string { if m != nil { return m.Version } return "" } type VersionResponse struct { // Version of the kubelet runtime API. Version string `protobuf:"bytes,1,opt,name=version,proto3" json:"version,omitempty"` // Name of the container runtime. RuntimeName string `protobuf:"bytes,2,opt,name=runtime_name,json=runtimeName,proto3" json:"runtime_name,omitempty"` // Version of the container runtime. The string must be // semver-compatible. RuntimeVersion string `protobuf:"bytes,3,opt,name=runtime_version,json=runtimeVersion,proto3" json:"runtime_version,omitempty"` // API version of the container runtime. The string must be // semver-compatible. RuntimeApiVersion string `protobuf:"bytes,4,opt,name=runtime_api_version,json=runtimeApiVersion,proto3" json:"runtime_api_version,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *VersionResponse) Reset() { *m = VersionResponse{} } func (*VersionResponse) ProtoMessage() {} func (*VersionResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{1} } func (m *VersionResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *VersionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_VersionResponse.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 *VersionResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_VersionResponse.Merge(m, src) } func (m *VersionResponse) XXX_Size() int { return m.Size() } func (m *VersionResponse) XXX_DiscardUnknown() { xxx_messageInfo_VersionResponse.DiscardUnknown(m) } var xxx_messageInfo_VersionResponse proto.InternalMessageInfo func (m *VersionResponse) GetVersion() string { if m != nil { return m.Version } return "" } func (m *VersionResponse) GetRuntimeName() string { if m != nil { return m.RuntimeName } return "" } func (m *VersionResponse) GetRuntimeVersion() string { if m != nil { return m.RuntimeVersion } return "" } func (m *VersionResponse) GetRuntimeApiVersion() string { if m != nil { return m.RuntimeApiVersion } return "" } // DNSConfig specifies the DNS servers and search domains of a sandbox. type DNSConfig struct { // List of DNS servers of the cluster. Servers []string `protobuf:"bytes,1,rep,name=servers,proto3" json:"servers,omitempty"` // List of DNS search domains of the cluster. Searches []string `protobuf:"bytes,2,rep,name=searches,proto3" json:"searches,omitempty"` // List of DNS options. See https://linux.die.net/man/5/resolv.conf // for all available options. Options []string `protobuf:"bytes,3,rep,name=options,proto3" json:"options,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *DNSConfig) Reset() { *m = DNSConfig{} } func (*DNSConfig) ProtoMessage() {} func (*DNSConfig) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{2} } func (m *DNSConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *DNSConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_DNSConfig.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 *DNSConfig) XXX_Merge(src proto.Message) { xxx_messageInfo_DNSConfig.Merge(m, src) } func (m *DNSConfig) XXX_Size() int { return m.Size() } func (m *DNSConfig) XXX_DiscardUnknown() { xxx_messageInfo_DNSConfig.DiscardUnknown(m) } var xxx_messageInfo_DNSConfig proto.InternalMessageInfo func (m *DNSConfig) GetServers() []string { if m != nil { return m.Servers } return nil } func (m *DNSConfig) GetSearches() []string { if m != nil { return m.Searches } return nil } func (m *DNSConfig) GetOptions() []string { if m != nil { return m.Options } return nil } // PortMapping specifies the port mapping configurations of a sandbox. type PortMapping struct { // Protocol of the port mapping. Protocol Protocol `protobuf:"varint,1,opt,name=protocol,proto3,enum=runtime.v1.Protocol" json:"protocol,omitempty"` // Port number within the container. Default: 0 (not specified). ContainerPort int32 `protobuf:"varint,2,opt,name=container_port,json=containerPort,proto3" json:"container_port,omitempty"` // Port number on the host. Default: 0 (not specified). HostPort int32 `protobuf:"varint,3,opt,name=host_port,json=hostPort,proto3" json:"host_port,omitempty"` // Host IP. HostIp string `protobuf:"bytes,4,opt,name=host_ip,json=hostIp,proto3" json:"host_ip,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PortMapping) Reset() { *m = PortMapping{} } func (*PortMapping) ProtoMessage() {} func (*PortMapping) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{3} } func (m *PortMapping) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PortMapping) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PortMapping.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 *PortMapping) XXX_Merge(src proto.Message) { xxx_messageInfo_PortMapping.Merge(m, src) } func (m *PortMapping) XXX_Size() int { return m.Size() } func (m *PortMapping) XXX_DiscardUnknown() { xxx_messageInfo_PortMapping.DiscardUnknown(m) } var xxx_messageInfo_PortMapping proto.InternalMessageInfo func (m *PortMapping) GetProtocol() Protocol { if m != nil { return m.Protocol } return Protocol_TCP } func (m *PortMapping) GetContainerPort() int32 { if m != nil { return m.ContainerPort } return 0 } func (m *PortMapping) GetHostPort() int32 { if m != nil { return m.HostPort } return 0 } func (m *PortMapping) GetHostIp() string { if m != nil { return m.HostIp } return "" } // Mount specifies a host volume to mount into a container. type Mount struct { // Path of the mount within the container. ContainerPath string `protobuf:"bytes,1,opt,name=container_path,json=containerPath,proto3" json:"container_path,omitempty"` // Path of the mount on the host. Has to be empty if the image field below // is provided, because those fields are mutually exclusive. If the image // field below is nil and the host path doesn't exist, then runtimes should // report an error. If the hostpath is a symbolic link, runtimes should // follow the symlink and mount the real destination to container. HostPath string `protobuf:"bytes,2,opt,name=host_path,json=hostPath,proto3" json:"host_path,omitempty"` // If set, the mount is read-only. Readonly bool `protobuf:"varint,3,opt,name=readonly,proto3" json:"readonly,omitempty"` // If set, the mount needs SELinux relabeling. SelinuxRelabel bool `protobuf:"varint,4,opt,name=selinux_relabel,json=selinuxRelabel,proto3" json:"selinux_relabel,omitempty"` // Requested propagation mode. Propagation MountPropagation `protobuf:"varint,5,opt,name=propagation,proto3,enum=runtime.v1.MountPropagation" json:"propagation,omitempty"` // 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"` // 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{} } func (*Mount) ProtoMessage() {} func (*Mount) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{4} } func (m *Mount) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Mount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Mount.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 *Mount) XXX_Merge(src proto.Message) { xxx_messageInfo_Mount.Merge(m, src) } func (m *Mount) XXX_Size() int { return m.Size() } func (m *Mount) XXX_DiscardUnknown() { xxx_messageInfo_Mount.DiscardUnknown(m) } var xxx_messageInfo_Mount proto.InternalMessageInfo func (m *Mount) GetContainerPath() string { if m != nil { return m.ContainerPath } return "" } func (m *Mount) GetHostPath() string { if m != nil { return m.HostPath } return "" } func (m *Mount) GetReadonly() bool { if m != nil { return m.Readonly } return false } func (m *Mount) GetSelinuxRelabel() bool { if m != nil { return m.SelinuxRelabel } return false } func (m *Mount) GetPropagation() MountPropagation { if m != nil { return m.Propagation } return MountPropagation_PROPAGATION_PRIVATE } func (m *Mount) GetUidMappings() []*IDMapping { if m != nil { return m.UidMappings } return nil } func (m *Mount) GetGidMappings() []*IDMapping { if m != nil { return m.GidMappings } 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. HostId uint32 `protobuf:"varint,1,opt,name=host_id,json=hostId,proto3" json:"host_id,omitempty"` // ContainerId is the id in the container. ContainerId uint32 `protobuf:"varint,2,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` // Length is the size of the range to map. Length uint32 `protobuf:"varint,3,opt,name=length,proto3" json:"length,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *IDMapping) Reset() { *m = IDMapping{} } func (*IDMapping) ProtoMessage() {} func (*IDMapping) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{5} } func (m *IDMapping) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *IDMapping) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_IDMapping.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 *IDMapping) XXX_Merge(src proto.Message) { xxx_messageInfo_IDMapping.Merge(m, src) } func (m *IDMapping) XXX_Size() int { return m.Size() } func (m *IDMapping) XXX_DiscardUnknown() { xxx_messageInfo_IDMapping.DiscardUnknown(m) } var xxx_messageInfo_IDMapping proto.InternalMessageInfo func (m *IDMapping) GetHostId() uint32 { if m != nil { return m.HostId } return 0 } func (m *IDMapping) GetContainerId() uint32 { if m != nil { return m.ContainerId } return 0 } func (m *IDMapping) GetLength() uint32 { if m != nil { return m.Length } return 0 } // UserNamespace describes the intended user namespace configuration for a pod sandbox. type UserNamespace struct { // Mode is the NamespaceMode for this UserNamespace. // Note: NamespaceMode for UserNamespace currently supports only POD and NODE, not CONTAINER OR TARGET. Mode NamespaceMode `protobuf:"varint,1,opt,name=mode,proto3,enum=runtime.v1.NamespaceMode" json:"mode,omitempty"` // Uids specifies the UID mappings for the user namespace. Uids []*IDMapping `protobuf:"bytes,2,rep,name=uids,proto3" json:"uids,omitempty"` // Gids specifies the GID mappings for the user namespace. Gids []*IDMapping `protobuf:"bytes,3,rep,name=gids,proto3" json:"gids,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *UserNamespace) Reset() { *m = UserNamespace{} } func (*UserNamespace) ProtoMessage() {} func (*UserNamespace) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{6} } func (m *UserNamespace) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *UserNamespace) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_UserNamespace.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 *UserNamespace) XXX_Merge(src proto.Message) { xxx_messageInfo_UserNamespace.Merge(m, src) } func (m *UserNamespace) XXX_Size() int { return m.Size() } func (m *UserNamespace) XXX_DiscardUnknown() { xxx_messageInfo_UserNamespace.DiscardUnknown(m) } var xxx_messageInfo_UserNamespace proto.InternalMessageInfo func (m *UserNamespace) GetMode() NamespaceMode { if m != nil { return m.Mode } return NamespaceMode_POD } func (m *UserNamespace) GetUids() []*IDMapping { if m != nil { return m.Uids } return nil } func (m *UserNamespace) GetGids() []*IDMapping { if m != nil { return m.Gids } return nil } // NamespaceOption provides options for Linux namespaces. type NamespaceOption struct { // Network namespace for this container/sandbox. // Note: There is currently no way to set CONTAINER scoped network in the Kubernetes API. // Namespaces currently set by the kubelet: POD, NODE Network NamespaceMode `protobuf:"varint,1,opt,name=network,proto3,enum=runtime.v1.NamespaceMode" json:"network,omitempty"` // PID namespace for this container/sandbox. // Note: The CRI default is POD, but the v1.PodSpec default is CONTAINER. // The kubelet's runtime manager will set this to CONTAINER explicitly for v1 pods. // Namespaces currently set by the kubelet: POD, CONTAINER, NODE, TARGET Pid NamespaceMode `protobuf:"varint,2,opt,name=pid,proto3,enum=runtime.v1.NamespaceMode" json:"pid,omitempty"` // IPC namespace for this container/sandbox. // Note: There is currently no way to set CONTAINER scoped IPC in the Kubernetes API. // Namespaces currently set by the kubelet: POD, NODE Ipc NamespaceMode `protobuf:"varint,3,opt,name=ipc,proto3,enum=runtime.v1.NamespaceMode" json:"ipc,omitempty"` // Target Container ID for NamespaceMode of TARGET. This container must have been // previously created in the same pod. It is not possible to specify different targets // for each namespace. TargetId string `protobuf:"bytes,4,opt,name=target_id,json=targetId,proto3" json:"target_id,omitempty"` // UsernsOptions for this pod sandbox. // The Kubelet picks the user namespace configuration to use for the pod sandbox. The mappings // are specified as part of the UserNamespace struct. If the struct is nil, then the POD mode // must be assumed. This is done for backward compatibility with older Kubelet versions that // do not set a user namespace. UsernsOptions *UserNamespace `protobuf:"bytes,5,opt,name=userns_options,json=usernsOptions,proto3" json:"userns_options,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *NamespaceOption) Reset() { *m = NamespaceOption{} } func (*NamespaceOption) ProtoMessage() {} func (*NamespaceOption) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{7} } func (m *NamespaceOption) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *NamespaceOption) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_NamespaceOption.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 *NamespaceOption) XXX_Merge(src proto.Message) { xxx_messageInfo_NamespaceOption.Merge(m, src) } func (m *NamespaceOption) XXX_Size() int { return m.Size() } func (m *NamespaceOption) XXX_DiscardUnknown() { xxx_messageInfo_NamespaceOption.DiscardUnknown(m) } var xxx_messageInfo_NamespaceOption proto.InternalMessageInfo func (m *NamespaceOption) GetNetwork() NamespaceMode { if m != nil { return m.Network } return NamespaceMode_POD } func (m *NamespaceOption) GetPid() NamespaceMode { if m != nil { return m.Pid } return NamespaceMode_POD } func (m *NamespaceOption) GetIpc() NamespaceMode { if m != nil { return m.Ipc } return NamespaceMode_POD } func (m *NamespaceOption) GetTargetId() string { if m != nil { return m.TargetId } return "" } func (m *NamespaceOption) GetUsernsOptions() *UserNamespace { if m != nil { return m.UsernsOptions } return nil } // Int64Value is the wrapper of int64. type Int64Value struct { // The value. Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Int64Value) Reset() { *m = Int64Value{} } func (*Int64Value) ProtoMessage() {} func (*Int64Value) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{8} } func (m *Int64Value) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Int64Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Int64Value.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 *Int64Value) XXX_Merge(src proto.Message) { xxx_messageInfo_Int64Value.Merge(m, src) } func (m *Int64Value) XXX_Size() int { return m.Size() } func (m *Int64Value) XXX_DiscardUnknown() { xxx_messageInfo_Int64Value.DiscardUnknown(m) } var xxx_messageInfo_Int64Value proto.InternalMessageInfo func (m *Int64Value) GetValue() int64 { if m != nil { return m.Value } return 0 } // LinuxSandboxSecurityContext holds linux security configuration that will be // applied to a sandbox. Note that: // 1. It does not apply to containers in the pods. // 2. It may not be applicable to a PodSandbox which does not contain any running // process. type LinuxSandboxSecurityContext struct { // Configurations for the sandbox's namespaces. // This will be used only if the PodSandbox uses namespace for isolation. NamespaceOptions *NamespaceOption `protobuf:"bytes,1,opt,name=namespace_options,json=namespaceOptions,proto3" json:"namespace_options,omitempty"` // Optional SELinux context to be applied. SelinuxOptions *SELinuxOption `protobuf:"bytes,2,opt,name=selinux_options,json=selinuxOptions,proto3" json:"selinux_options,omitempty"` // UID to run sandbox processes as, when applicable. RunAsUser *Int64Value `protobuf:"bytes,3,opt,name=run_as_user,json=runAsUser,proto3" json:"run_as_user,omitempty"` // GID to run sandbox processes as, when applicable. run_as_group should only // be specified when run_as_user is specified; otherwise, the runtime MUST error. 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 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. // This allows a sandbox to take additional security precautions if no // privileged containers are expected to be run. Privileged bool `protobuf:"varint,6,opt,name=privileged,proto3" json:"privileged,omitempty"` // Seccomp profile for the sandbox. Seccomp *SecurityProfile `protobuf:"bytes,9,opt,name=seccomp,proto3" json:"seccomp,omitempty"` // AppArmor profile for the sandbox. Apparmor *SecurityProfile `protobuf:"bytes,10,opt,name=apparmor,proto3" json:"apparmor,omitempty"` // Seccomp profile for the sandbox, candidate values are: // - runtime/default: the default profile for the container runtime // - unconfined: unconfined profile, ie, no seccomp sandboxing // - localhost/: the profile installed on the node. // is the full path of the profile. // // Default: "", which is identical with unconfined. SeccompProfilePath string `protobuf:"bytes,7,opt,name=seccomp_profile_path,json=seccompProfilePath,proto3" json:"seccomp_profile_path,omitempty"` // Deprecated: Do not use. XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *LinuxSandboxSecurityContext) Reset() { *m = LinuxSandboxSecurityContext{} } func (*LinuxSandboxSecurityContext) ProtoMessage() {} func (*LinuxSandboxSecurityContext) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{9} } func (m *LinuxSandboxSecurityContext) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *LinuxSandboxSecurityContext) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_LinuxSandboxSecurityContext.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 *LinuxSandboxSecurityContext) XXX_Merge(src proto.Message) { xxx_messageInfo_LinuxSandboxSecurityContext.Merge(m, src) } func (m *LinuxSandboxSecurityContext) XXX_Size() int { return m.Size() } func (m *LinuxSandboxSecurityContext) XXX_DiscardUnknown() { xxx_messageInfo_LinuxSandboxSecurityContext.DiscardUnknown(m) } var xxx_messageInfo_LinuxSandboxSecurityContext proto.InternalMessageInfo func (m *LinuxSandboxSecurityContext) GetNamespaceOptions() *NamespaceOption { if m != nil { return m.NamespaceOptions } return nil } func (m *LinuxSandboxSecurityContext) GetSelinuxOptions() *SELinuxOption { if m != nil { return m.SelinuxOptions } return nil } func (m *LinuxSandboxSecurityContext) GetRunAsUser() *Int64Value { if m != nil { return m.RunAsUser } return nil } func (m *LinuxSandboxSecurityContext) GetRunAsGroup() *Int64Value { if m != nil { return m.RunAsGroup } return nil } func (m *LinuxSandboxSecurityContext) GetReadonlyRootfs() bool { if m != nil { return m.ReadonlyRootfs } return false } func (m *LinuxSandboxSecurityContext) GetSupplementalGroups() []int64 { if m != nil { return m.SupplementalGroups } 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 } return false } func (m *LinuxSandboxSecurityContext) GetSeccomp() *SecurityProfile { if m != nil { return m.Seccomp } return nil } func (m *LinuxSandboxSecurityContext) GetApparmor() *SecurityProfile { if m != nil { return m.Apparmor } return nil } // Deprecated: Do not use. func (m *LinuxSandboxSecurityContext) GetSeccompProfilePath() string { if m != nil { return m.SeccompProfilePath } return "" } // A security profile which can be used for sandboxes and containers. type SecurityProfile struct { // Indicator which `ProfileType` should be applied. ProfileType SecurityProfile_ProfileType `protobuf:"varint,1,opt,name=profile_type,json=profileType,proto3,enum=runtime.v1.SecurityProfile_ProfileType" json:"profile_type,omitempty"` // Indicates that a pre-defined profile on the node should be used. // Must only be set if `ProfileType` is `Localhost`. // For seccomp, it must be an absolute path to the seccomp profile. // For AppArmor, this field is the AppArmor `/` LocalhostRef string `protobuf:"bytes,2,opt,name=localhost_ref,json=localhostRef,proto3" json:"localhost_ref,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SecurityProfile) Reset() { *m = SecurityProfile{} } func (*SecurityProfile) ProtoMessage() {} func (*SecurityProfile) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{10} } func (m *SecurityProfile) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SecurityProfile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SecurityProfile.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 *SecurityProfile) XXX_Merge(src proto.Message) { xxx_messageInfo_SecurityProfile.Merge(m, src) } func (m *SecurityProfile) XXX_Size() int { return m.Size() } func (m *SecurityProfile) XXX_DiscardUnknown() { xxx_messageInfo_SecurityProfile.DiscardUnknown(m) } var xxx_messageInfo_SecurityProfile proto.InternalMessageInfo func (m *SecurityProfile) GetProfileType() SecurityProfile_ProfileType { if m != nil { return m.ProfileType } return SecurityProfile_RuntimeDefault } func (m *SecurityProfile) GetLocalhostRef() string { if m != nil { return m.LocalhostRef } return "" } // LinuxPodSandboxConfig holds platform-specific configurations for Linux // host platforms and Linux-based containers. type LinuxPodSandboxConfig struct { // Parent cgroup of the PodSandbox. // The cgroupfs style syntax will be used, but the container runtime can // convert it to systemd semantics if needed. CgroupParent string `protobuf:"bytes,1,opt,name=cgroup_parent,json=cgroupParent,proto3" json:"cgroup_parent,omitempty"` // LinuxSandboxSecurityContext holds sandbox security attributes. SecurityContext *LinuxSandboxSecurityContext `protobuf:"bytes,2,opt,name=security_context,json=securityContext,proto3" json:"security_context,omitempty"` // Sysctls holds linux sysctls config for the sandbox. Sysctls map[string]string `protobuf:"bytes,3,rep,name=sysctls,proto3" json:"sysctls,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // Optional overhead represents the overheads associated with this sandbox Overhead *LinuxContainerResources `protobuf:"bytes,4,opt,name=overhead,proto3" json:"overhead,omitempty"` // Optional resources represents the sum of container resources for this sandbox Resources *LinuxContainerResources `protobuf:"bytes,5,opt,name=resources,proto3" json:"resources,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *LinuxPodSandboxConfig) Reset() { *m = LinuxPodSandboxConfig{} } func (*LinuxPodSandboxConfig) ProtoMessage() {} func (*LinuxPodSandboxConfig) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{11} } func (m *LinuxPodSandboxConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *LinuxPodSandboxConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_LinuxPodSandboxConfig.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 *LinuxPodSandboxConfig) XXX_Merge(src proto.Message) { xxx_messageInfo_LinuxPodSandboxConfig.Merge(m, src) } func (m *LinuxPodSandboxConfig) XXX_Size() int { return m.Size() } func (m *LinuxPodSandboxConfig) XXX_DiscardUnknown() { xxx_messageInfo_LinuxPodSandboxConfig.DiscardUnknown(m) } var xxx_messageInfo_LinuxPodSandboxConfig proto.InternalMessageInfo func (m *LinuxPodSandboxConfig) GetCgroupParent() string { if m != nil { return m.CgroupParent } return "" } func (m *LinuxPodSandboxConfig) GetSecurityContext() *LinuxSandboxSecurityContext { if m != nil { return m.SecurityContext } return nil } func (m *LinuxPodSandboxConfig) GetSysctls() map[string]string { if m != nil { return m.Sysctls } return nil } func (m *LinuxPodSandboxConfig) GetOverhead() *LinuxContainerResources { if m != nil { return m.Overhead } return nil } func (m *LinuxPodSandboxConfig) GetResources() *LinuxContainerResources { if m != nil { return m.Resources } return nil } // PodSandboxMetadata holds all necessary information for building the sandbox name. // The container runtime is encouraged to expose the metadata associated with the // PodSandbox in its user interface for better user experience. For example, // the runtime can construct a unique PodSandboxName based on the metadata. type PodSandboxMetadata struct { // Pod name of the sandbox. Same as the pod name in the Pod ObjectMeta. Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` // Pod UID of the sandbox. Same as the pod UID in the Pod ObjectMeta. Uid string `protobuf:"bytes,2,opt,name=uid,proto3" json:"uid,omitempty"` // Pod namespace of the sandbox. Same as the pod namespace in the Pod ObjectMeta. Namespace string `protobuf:"bytes,3,opt,name=namespace,proto3" json:"namespace,omitempty"` // Attempt number of creating the sandbox. Default: 0. Attempt uint32 `protobuf:"varint,4,opt,name=attempt,proto3" json:"attempt,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PodSandboxMetadata) Reset() { *m = PodSandboxMetadata{} } func (*PodSandboxMetadata) ProtoMessage() {} func (*PodSandboxMetadata) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{12} } func (m *PodSandboxMetadata) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PodSandboxMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PodSandboxMetadata.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 *PodSandboxMetadata) XXX_Merge(src proto.Message) { xxx_messageInfo_PodSandboxMetadata.Merge(m, src) } func (m *PodSandboxMetadata) XXX_Size() int { return m.Size() } func (m *PodSandboxMetadata) XXX_DiscardUnknown() { xxx_messageInfo_PodSandboxMetadata.DiscardUnknown(m) } var xxx_messageInfo_PodSandboxMetadata proto.InternalMessageInfo func (m *PodSandboxMetadata) GetName() string { if m != nil { return m.Name } return "" } func (m *PodSandboxMetadata) GetUid() string { if m != nil { return m.Uid } return "" } func (m *PodSandboxMetadata) GetNamespace() string { if m != nil { return m.Namespace } return "" } func (m *PodSandboxMetadata) GetAttempt() uint32 { if m != nil { return m.Attempt } return 0 } // PodSandboxConfig holds all the required and optional fields for creating a // sandbox. type PodSandboxConfig struct { // Metadata of the sandbox. This information will uniquely identify the // sandbox, and the runtime should leverage this to ensure correct // operation. The runtime may also use this information to improve UX, such // as by constructing a readable name. Metadata *PodSandboxMetadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"` // Hostname of the sandbox. Hostname could only be empty when the pod // network namespace is NODE. Hostname string `protobuf:"bytes,2,opt,name=hostname,proto3" json:"hostname,omitempty"` // Path to the directory on the host in which container log files are // stored. // By default the log of a container going into the LogDirectory will be // hooked up to STDOUT and STDERR. However, the LogDirectory may contain // binary log files with structured logging data from the individual // containers. For example, the files might be newline separated JSON // structured logs, systemd-journald journal files, gRPC trace files, etc. // E.g., // // PodSandboxConfig.LogDirectory = `/var/log/pods/__/` // ContainerConfig.LogPath = `containerName/Instance#.log` LogDirectory string `protobuf:"bytes,3,opt,name=log_directory,json=logDirectory,proto3" json:"log_directory,omitempty"` // DNS config for the sandbox. DnsConfig *DNSConfig `protobuf:"bytes,4,opt,name=dns_config,json=dnsConfig,proto3" json:"dns_config,omitempty"` // Port mappings for the sandbox. PortMappings []*PortMapping `protobuf:"bytes,5,rep,name=port_mappings,json=portMappings,proto3" json:"port_mappings,omitempty"` // Key-value pairs that may be used to scope and select individual resources. Labels map[string]string `protobuf:"bytes,6,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // Unstructured key-value map that may be set by the kubelet to store and // retrieve arbitrary metadata. This will include any annotations set on a // pod through the Kubernetes API. // // Annotations MUST NOT be altered by the runtime; the annotations stored // here MUST be returned in the PodSandboxStatus associated with the pod // this PodSandboxConfig creates. // // In general, in order to preserve a well-defined interface between the // kubelet and the container runtime, annotations SHOULD NOT influence // runtime behaviour. // // Annotations can also be useful for runtime authors to experiment with // new features that are opaque to the Kubernetes APIs (both user-facing // and the CRI). Whenever possible, however, runtime authors SHOULD // consider proposing new typed fields for any new features instead. Annotations map[string]string `protobuf:"bytes,7,rep,name=annotations,proto3" json:"annotations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // Optional configurations specific to Linux hosts. Linux *LinuxPodSandboxConfig `protobuf:"bytes,8,opt,name=linux,proto3" json:"linux,omitempty"` // Optional configurations specific to Windows hosts. Windows *WindowsPodSandboxConfig `protobuf:"bytes,9,opt,name=windows,proto3" json:"windows,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PodSandboxConfig) Reset() { *m = PodSandboxConfig{} } func (*PodSandboxConfig) ProtoMessage() {} func (*PodSandboxConfig) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{13} } func (m *PodSandboxConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PodSandboxConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PodSandboxConfig.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 *PodSandboxConfig) XXX_Merge(src proto.Message) { xxx_messageInfo_PodSandboxConfig.Merge(m, src) } func (m *PodSandboxConfig) XXX_Size() int { return m.Size() } func (m *PodSandboxConfig) XXX_DiscardUnknown() { xxx_messageInfo_PodSandboxConfig.DiscardUnknown(m) } var xxx_messageInfo_PodSandboxConfig proto.InternalMessageInfo func (m *PodSandboxConfig) GetMetadata() *PodSandboxMetadata { if m != nil { return m.Metadata } return nil } func (m *PodSandboxConfig) GetHostname() string { if m != nil { return m.Hostname } return "" } func (m *PodSandboxConfig) GetLogDirectory() string { if m != nil { return m.LogDirectory } return "" } func (m *PodSandboxConfig) GetDnsConfig() *DNSConfig { if m != nil { return m.DnsConfig } return nil } func (m *PodSandboxConfig) GetPortMappings() []*PortMapping { if m != nil { return m.PortMappings } return nil } func (m *PodSandboxConfig) GetLabels() map[string]string { if m != nil { return m.Labels } return nil } func (m *PodSandboxConfig) GetAnnotations() map[string]string { if m != nil { return m.Annotations } return nil } func (m *PodSandboxConfig) GetLinux() *LinuxPodSandboxConfig { if m != nil { return m.Linux } return nil } func (m *PodSandboxConfig) GetWindows() *WindowsPodSandboxConfig { if m != nil { return m.Windows } return nil } type RunPodSandboxRequest struct { // Configuration for creating a PodSandbox. Config *PodSandboxConfig `protobuf:"bytes,1,opt,name=config,proto3" json:"config,omitempty"` // Named runtime configuration to use for this PodSandbox. // If the runtime handler is unknown, this request should be rejected. An // empty string should select the default handler, equivalent to the // behavior before this feature was added. // See https://git.k8s.io/enhancements/keps/sig-node/585-runtime-class RuntimeHandler string `protobuf:"bytes,2,opt,name=runtime_handler,json=runtimeHandler,proto3" json:"runtime_handler,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RunPodSandboxRequest) Reset() { *m = RunPodSandboxRequest{} } func (*RunPodSandboxRequest) ProtoMessage() {} func (*RunPodSandboxRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{14} } func (m *RunPodSandboxRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RunPodSandboxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RunPodSandboxRequest.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 *RunPodSandboxRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RunPodSandboxRequest.Merge(m, src) } func (m *RunPodSandboxRequest) XXX_Size() int { return m.Size() } func (m *RunPodSandboxRequest) XXX_DiscardUnknown() { xxx_messageInfo_RunPodSandboxRequest.DiscardUnknown(m) } var xxx_messageInfo_RunPodSandboxRequest proto.InternalMessageInfo func (m *RunPodSandboxRequest) GetConfig() *PodSandboxConfig { if m != nil { return m.Config } return nil } func (m *RunPodSandboxRequest) GetRuntimeHandler() string { if m != nil { return m.RuntimeHandler } return "" } type RunPodSandboxResponse struct { // ID of the PodSandbox to run. PodSandboxId string `protobuf:"bytes,1,opt,name=pod_sandbox_id,json=podSandboxId,proto3" json:"pod_sandbox_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RunPodSandboxResponse) Reset() { *m = RunPodSandboxResponse{} } func (*RunPodSandboxResponse) ProtoMessage() {} func (*RunPodSandboxResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{15} } func (m *RunPodSandboxResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RunPodSandboxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RunPodSandboxResponse.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 *RunPodSandboxResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RunPodSandboxResponse.Merge(m, src) } func (m *RunPodSandboxResponse) XXX_Size() int { return m.Size() } func (m *RunPodSandboxResponse) XXX_DiscardUnknown() { xxx_messageInfo_RunPodSandboxResponse.DiscardUnknown(m) } var xxx_messageInfo_RunPodSandboxResponse proto.InternalMessageInfo func (m *RunPodSandboxResponse) GetPodSandboxId() string { if m != nil { return m.PodSandboxId } return "" } type StopPodSandboxRequest struct { // ID of the PodSandbox to stop. PodSandboxId string `protobuf:"bytes,1,opt,name=pod_sandbox_id,json=podSandboxId,proto3" json:"pod_sandbox_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StopPodSandboxRequest) Reset() { *m = StopPodSandboxRequest{} } func (*StopPodSandboxRequest) ProtoMessage() {} func (*StopPodSandboxRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{16} } func (m *StopPodSandboxRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *StopPodSandboxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_StopPodSandboxRequest.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 *StopPodSandboxRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_StopPodSandboxRequest.Merge(m, src) } func (m *StopPodSandboxRequest) XXX_Size() int { return m.Size() } func (m *StopPodSandboxRequest) XXX_DiscardUnknown() { xxx_messageInfo_StopPodSandboxRequest.DiscardUnknown(m) } var xxx_messageInfo_StopPodSandboxRequest proto.InternalMessageInfo func (m *StopPodSandboxRequest) GetPodSandboxId() string { if m != nil { return m.PodSandboxId } return "" } type StopPodSandboxResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StopPodSandboxResponse) Reset() { *m = StopPodSandboxResponse{} } func (*StopPodSandboxResponse) ProtoMessage() {} func (*StopPodSandboxResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{17} } func (m *StopPodSandboxResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *StopPodSandboxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_StopPodSandboxResponse.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 *StopPodSandboxResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_StopPodSandboxResponse.Merge(m, src) } func (m *StopPodSandboxResponse) XXX_Size() int { return m.Size() } func (m *StopPodSandboxResponse) XXX_DiscardUnknown() { xxx_messageInfo_StopPodSandboxResponse.DiscardUnknown(m) } var xxx_messageInfo_StopPodSandboxResponse proto.InternalMessageInfo type RemovePodSandboxRequest struct { // ID of the PodSandbox to remove. PodSandboxId string `protobuf:"bytes,1,opt,name=pod_sandbox_id,json=podSandboxId,proto3" json:"pod_sandbox_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RemovePodSandboxRequest) Reset() { *m = RemovePodSandboxRequest{} } func (*RemovePodSandboxRequest) ProtoMessage() {} func (*RemovePodSandboxRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{18} } func (m *RemovePodSandboxRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RemovePodSandboxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RemovePodSandboxRequest.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 *RemovePodSandboxRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RemovePodSandboxRequest.Merge(m, src) } func (m *RemovePodSandboxRequest) XXX_Size() int { return m.Size() } func (m *RemovePodSandboxRequest) XXX_DiscardUnknown() { xxx_messageInfo_RemovePodSandboxRequest.DiscardUnknown(m) } var xxx_messageInfo_RemovePodSandboxRequest proto.InternalMessageInfo func (m *RemovePodSandboxRequest) GetPodSandboxId() string { if m != nil { return m.PodSandboxId } return "" } type RemovePodSandboxResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RemovePodSandboxResponse) Reset() { *m = RemovePodSandboxResponse{} } func (*RemovePodSandboxResponse) ProtoMessage() {} func (*RemovePodSandboxResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{19} } func (m *RemovePodSandboxResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RemovePodSandboxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RemovePodSandboxResponse.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 *RemovePodSandboxResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RemovePodSandboxResponse.Merge(m, src) } func (m *RemovePodSandboxResponse) XXX_Size() int { return m.Size() } func (m *RemovePodSandboxResponse) XXX_DiscardUnknown() { xxx_messageInfo_RemovePodSandboxResponse.DiscardUnknown(m) } var xxx_messageInfo_RemovePodSandboxResponse proto.InternalMessageInfo type PodSandboxStatusRequest struct { // ID of the PodSandbox for which to retrieve status. PodSandboxId string `protobuf:"bytes,1,opt,name=pod_sandbox_id,json=podSandboxId,proto3" json:"pod_sandbox_id,omitempty"` // Verbose indicates whether to return extra information about the pod sandbox. Verbose bool `protobuf:"varint,2,opt,name=verbose,proto3" json:"verbose,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PodSandboxStatusRequest) Reset() { *m = PodSandboxStatusRequest{} } func (*PodSandboxStatusRequest) ProtoMessage() {} func (*PodSandboxStatusRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{20} } func (m *PodSandboxStatusRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PodSandboxStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PodSandboxStatusRequest.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 *PodSandboxStatusRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_PodSandboxStatusRequest.Merge(m, src) } func (m *PodSandboxStatusRequest) XXX_Size() int { return m.Size() } func (m *PodSandboxStatusRequest) XXX_DiscardUnknown() { xxx_messageInfo_PodSandboxStatusRequest.DiscardUnknown(m) } var xxx_messageInfo_PodSandboxStatusRequest proto.InternalMessageInfo func (m *PodSandboxStatusRequest) GetPodSandboxId() string { if m != nil { return m.PodSandboxId } return "" } func (m *PodSandboxStatusRequest) GetVerbose() bool { if m != nil { return m.Verbose } return false } // PodIP represents an ip of a Pod type PodIP struct { // an ip is a string representation of an IPv4 or an IPv6 Ip string `protobuf:"bytes,1,opt,name=ip,proto3" json:"ip,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PodIP) Reset() { *m = PodIP{} } func (*PodIP) ProtoMessage() {} func (*PodIP) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{21} } func (m *PodIP) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PodIP) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PodIP.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 *PodIP) XXX_Merge(src proto.Message) { xxx_messageInfo_PodIP.Merge(m, src) } func (m *PodIP) XXX_Size() int { return m.Size() } func (m *PodIP) XXX_DiscardUnknown() { xxx_messageInfo_PodIP.DiscardUnknown(m) } var xxx_messageInfo_PodIP proto.InternalMessageInfo func (m *PodIP) GetIp() string { if m != nil { return m.Ip } return "" } // PodSandboxNetworkStatus is the status of the network for a PodSandbox. // Currently ignored for pods sharing the host networking namespace. type PodSandboxNetworkStatus struct { // IP address of the PodSandbox. Ip string `protobuf:"bytes,1,opt,name=ip,proto3" json:"ip,omitempty"` // list of additional ips (not inclusive of PodSandboxNetworkStatus.Ip) of the PodSandBoxNetworkStatus AdditionalIps []*PodIP `protobuf:"bytes,2,rep,name=additional_ips,json=additionalIps,proto3" json:"additional_ips,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PodSandboxNetworkStatus) Reset() { *m = PodSandboxNetworkStatus{} } func (*PodSandboxNetworkStatus) ProtoMessage() {} func (*PodSandboxNetworkStatus) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{22} } func (m *PodSandboxNetworkStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PodSandboxNetworkStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PodSandboxNetworkStatus.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 *PodSandboxNetworkStatus) XXX_Merge(src proto.Message) { xxx_messageInfo_PodSandboxNetworkStatus.Merge(m, src) } func (m *PodSandboxNetworkStatus) XXX_Size() int { return m.Size() } func (m *PodSandboxNetworkStatus) XXX_DiscardUnknown() { xxx_messageInfo_PodSandboxNetworkStatus.DiscardUnknown(m) } var xxx_messageInfo_PodSandboxNetworkStatus proto.InternalMessageInfo func (m *PodSandboxNetworkStatus) GetIp() string { if m != nil { return m.Ip } return "" } func (m *PodSandboxNetworkStatus) GetAdditionalIps() []*PodIP { if m != nil { return m.AdditionalIps } return nil } // Namespace contains paths to the namespaces. type Namespace struct { // Namespace options for Linux namespaces. Options *NamespaceOption `protobuf:"bytes,2,opt,name=options,proto3" json:"options,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Namespace) Reset() { *m = Namespace{} } func (*Namespace) ProtoMessage() {} func (*Namespace) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{23} } func (m *Namespace) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Namespace) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Namespace.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 *Namespace) XXX_Merge(src proto.Message) { xxx_messageInfo_Namespace.Merge(m, src) } func (m *Namespace) XXX_Size() int { return m.Size() } func (m *Namespace) XXX_DiscardUnknown() { xxx_messageInfo_Namespace.DiscardUnknown(m) } var xxx_messageInfo_Namespace proto.InternalMessageInfo func (m *Namespace) GetOptions() *NamespaceOption { if m != nil { return m.Options } return nil } // LinuxSandboxStatus contains status specific to Linux sandboxes. type LinuxPodSandboxStatus struct { // Paths to the sandbox's namespaces. Namespaces *Namespace `protobuf:"bytes,1,opt,name=namespaces,proto3" json:"namespaces,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *LinuxPodSandboxStatus) Reset() { *m = LinuxPodSandboxStatus{} } func (*LinuxPodSandboxStatus) ProtoMessage() {} func (*LinuxPodSandboxStatus) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{24} } func (m *LinuxPodSandboxStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *LinuxPodSandboxStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_LinuxPodSandboxStatus.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 *LinuxPodSandboxStatus) XXX_Merge(src proto.Message) { xxx_messageInfo_LinuxPodSandboxStatus.Merge(m, src) } func (m *LinuxPodSandboxStatus) XXX_Size() int { return m.Size() } func (m *LinuxPodSandboxStatus) XXX_DiscardUnknown() { xxx_messageInfo_LinuxPodSandboxStatus.DiscardUnknown(m) } var xxx_messageInfo_LinuxPodSandboxStatus proto.InternalMessageInfo func (m *LinuxPodSandboxStatus) GetNamespaces() *Namespace { if m != nil { return m.Namespaces } return nil } // PodSandboxStatus contains the status of the PodSandbox. type PodSandboxStatus struct { // ID of the sandbox. Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` // Metadata of the sandbox. Metadata *PodSandboxMetadata `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"` // State of the sandbox. State PodSandboxState `protobuf:"varint,3,opt,name=state,proto3,enum=runtime.v1.PodSandboxState" json:"state,omitempty"` // Creation timestamp of the sandbox in nanoseconds. Must be > 0. CreatedAt int64 `protobuf:"varint,4,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` // Network contains network status if network is handled by the runtime. Network *PodSandboxNetworkStatus `protobuf:"bytes,5,opt,name=network,proto3" json:"network,omitempty"` // Linux-specific status to a pod sandbox. Linux *LinuxPodSandboxStatus `protobuf:"bytes,6,opt,name=linux,proto3" json:"linux,omitempty"` // Labels are key-value pairs that may be used to scope and select individual resources. Labels map[string]string `protobuf:"bytes,7,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // Unstructured key-value map holding arbitrary metadata. // Annotations MUST NOT be altered by the runtime; the value of this field // MUST be identical to that of the corresponding PodSandboxConfig used to // instantiate the pod sandbox this status represents. Annotations map[string]string `protobuf:"bytes,8,rep,name=annotations,proto3" json:"annotations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // runtime configuration used for this PodSandbox. RuntimeHandler string `protobuf:"bytes,9,opt,name=runtime_handler,json=runtimeHandler,proto3" json:"runtime_handler,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PodSandboxStatus) Reset() { *m = PodSandboxStatus{} } func (*PodSandboxStatus) ProtoMessage() {} func (*PodSandboxStatus) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{25} } func (m *PodSandboxStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PodSandboxStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PodSandboxStatus.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 *PodSandboxStatus) XXX_Merge(src proto.Message) { xxx_messageInfo_PodSandboxStatus.Merge(m, src) } func (m *PodSandboxStatus) XXX_Size() int { return m.Size() } func (m *PodSandboxStatus) XXX_DiscardUnknown() { xxx_messageInfo_PodSandboxStatus.DiscardUnknown(m) } var xxx_messageInfo_PodSandboxStatus proto.InternalMessageInfo func (m *PodSandboxStatus) GetId() string { if m != nil { return m.Id } return "" } func (m *PodSandboxStatus) GetMetadata() *PodSandboxMetadata { if m != nil { return m.Metadata } return nil } func (m *PodSandboxStatus) GetState() PodSandboxState { if m != nil { return m.State } return PodSandboxState_SANDBOX_READY } func (m *PodSandboxStatus) GetCreatedAt() int64 { if m != nil { return m.CreatedAt } return 0 } func (m *PodSandboxStatus) GetNetwork() *PodSandboxNetworkStatus { if m != nil { return m.Network } return nil } func (m *PodSandboxStatus) GetLinux() *LinuxPodSandboxStatus { if m != nil { return m.Linux } return nil } func (m *PodSandboxStatus) GetLabels() map[string]string { if m != nil { return m.Labels } return nil } func (m *PodSandboxStatus) GetAnnotations() map[string]string { if m != nil { return m.Annotations } return nil } func (m *PodSandboxStatus) GetRuntimeHandler() string { if m != nil { return m.RuntimeHandler } return "" } type PodSandboxStatusResponse struct { // Status of the PodSandbox. Status *PodSandboxStatus `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"` // Info is extra information of the PodSandbox. The key could be arbitrary string, and // value should be in json format. The information could include anything useful for // debug, e.g. network namespace for linux container based 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"` // Container statuses ContainersStatuses []*ContainerStatus `protobuf:"bytes,3,rep,name=containers_statuses,json=containersStatuses,proto3" json:"containers_statuses,omitempty"` // Timestamp in nanoseconds at which container and pod statuses were recorded Timestamp int64 `protobuf:"varint,4,opt,name=timestamp,proto3" json:"timestamp,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PodSandboxStatusResponse) Reset() { *m = PodSandboxStatusResponse{} } func (*PodSandboxStatusResponse) ProtoMessage() {} func (*PodSandboxStatusResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{26} } func (m *PodSandboxStatusResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PodSandboxStatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PodSandboxStatusResponse.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 *PodSandboxStatusResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_PodSandboxStatusResponse.Merge(m, src) } func (m *PodSandboxStatusResponse) XXX_Size() int { return m.Size() } func (m *PodSandboxStatusResponse) XXX_DiscardUnknown() { xxx_messageInfo_PodSandboxStatusResponse.DiscardUnknown(m) } var xxx_messageInfo_PodSandboxStatusResponse proto.InternalMessageInfo func (m *PodSandboxStatusResponse) GetStatus() *PodSandboxStatus { if m != nil { return m.Status } return nil } func (m *PodSandboxStatusResponse) GetInfo() map[string]string { if m != nil { return m.Info } return nil } func (m *PodSandboxStatusResponse) GetContainersStatuses() []*ContainerStatus { if m != nil { return m.ContainersStatuses } return nil } func (m *PodSandboxStatusResponse) GetTimestamp() int64 { if m != nil { return m.Timestamp } return 0 } // PodSandboxStateValue is the wrapper of PodSandboxState. type PodSandboxStateValue struct { // State of the sandbox. State PodSandboxState `protobuf:"varint,1,opt,name=state,proto3,enum=runtime.v1.PodSandboxState" json:"state,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PodSandboxStateValue) Reset() { *m = PodSandboxStateValue{} } func (*PodSandboxStateValue) ProtoMessage() {} func (*PodSandboxStateValue) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{27} } func (m *PodSandboxStateValue) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PodSandboxStateValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PodSandboxStateValue.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 *PodSandboxStateValue) XXX_Merge(src proto.Message) { xxx_messageInfo_PodSandboxStateValue.Merge(m, src) } func (m *PodSandboxStateValue) XXX_Size() int { return m.Size() } func (m *PodSandboxStateValue) XXX_DiscardUnknown() { xxx_messageInfo_PodSandboxStateValue.DiscardUnknown(m) } var xxx_messageInfo_PodSandboxStateValue proto.InternalMessageInfo func (m *PodSandboxStateValue) GetState() PodSandboxState { if m != nil { return m.State } return PodSandboxState_SANDBOX_READY } // PodSandboxFilter is used to filter a list of PodSandboxes. // All those fields are combined with 'AND' type PodSandboxFilter struct { // ID of the sandbox. Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` // State of the sandbox. State *PodSandboxStateValue `protobuf:"bytes,2,opt,name=state,proto3" json:"state,omitempty"` // LabelSelector to select matches. // Only api.MatchLabels is supported for now and the requirements // are ANDed. MatchExpressions is not supported yet. LabelSelector map[string]string `protobuf:"bytes,3,rep,name=label_selector,json=labelSelector,proto3" json:"label_selector,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:"-"` } func (m *PodSandboxFilter) Reset() { *m = PodSandboxFilter{} } func (*PodSandboxFilter) ProtoMessage() {} func (*PodSandboxFilter) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{28} } func (m *PodSandboxFilter) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PodSandboxFilter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PodSandboxFilter.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 *PodSandboxFilter) XXX_Merge(src proto.Message) { xxx_messageInfo_PodSandboxFilter.Merge(m, src) } func (m *PodSandboxFilter) XXX_Size() int { return m.Size() } func (m *PodSandboxFilter) XXX_DiscardUnknown() { xxx_messageInfo_PodSandboxFilter.DiscardUnknown(m) } var xxx_messageInfo_PodSandboxFilter proto.InternalMessageInfo func (m *PodSandboxFilter) GetId() string { if m != nil { return m.Id } return "" } func (m *PodSandboxFilter) GetState() *PodSandboxStateValue { if m != nil { return m.State } return nil } func (m *PodSandboxFilter) GetLabelSelector() map[string]string { if m != nil { return m.LabelSelector } return nil } type ListPodSandboxRequest struct { // PodSandboxFilter to filter a list of PodSandboxes. Filter *PodSandboxFilter `protobuf:"bytes,1,opt,name=filter,proto3" json:"filter,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListPodSandboxRequest) Reset() { *m = ListPodSandboxRequest{} } func (*ListPodSandboxRequest) ProtoMessage() {} func (*ListPodSandboxRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{29} } func (m *ListPodSandboxRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListPodSandboxRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListPodSandboxRequest.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 *ListPodSandboxRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ListPodSandboxRequest.Merge(m, src) } func (m *ListPodSandboxRequest) XXX_Size() int { return m.Size() } func (m *ListPodSandboxRequest) XXX_DiscardUnknown() { xxx_messageInfo_ListPodSandboxRequest.DiscardUnknown(m) } var xxx_messageInfo_ListPodSandboxRequest proto.InternalMessageInfo func (m *ListPodSandboxRequest) GetFilter() *PodSandboxFilter { if m != nil { return m.Filter } return nil } // PodSandbox contains minimal information about a sandbox. type PodSandbox struct { // ID of the PodSandbox. Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` // Metadata of the PodSandbox. Metadata *PodSandboxMetadata `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"` // State of the PodSandbox. State PodSandboxState `protobuf:"varint,3,opt,name=state,proto3,enum=runtime.v1.PodSandboxState" json:"state,omitempty"` // Creation timestamps of the PodSandbox in nanoseconds. Must be > 0. CreatedAt int64 `protobuf:"varint,4,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` // Labels of the PodSandbox. Labels map[string]string `protobuf:"bytes,5,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // Unstructured key-value map holding arbitrary metadata. // Annotations MUST NOT be altered by the runtime; the value of this field // MUST be identical to that of the corresponding PodSandboxConfig used to // instantiate this PodSandbox. Annotations map[string]string `protobuf:"bytes,6,rep,name=annotations,proto3" json:"annotations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // runtime configuration used for this PodSandbox. RuntimeHandler string `protobuf:"bytes,7,opt,name=runtime_handler,json=runtimeHandler,proto3" json:"runtime_handler,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PodSandbox) Reset() { *m = PodSandbox{} } func (*PodSandbox) ProtoMessage() {} func (*PodSandbox) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{30} } func (m *PodSandbox) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PodSandbox) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PodSandbox.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 *PodSandbox) XXX_Merge(src proto.Message) { xxx_messageInfo_PodSandbox.Merge(m, src) } func (m *PodSandbox) XXX_Size() int { return m.Size() } func (m *PodSandbox) XXX_DiscardUnknown() { xxx_messageInfo_PodSandbox.DiscardUnknown(m) } var xxx_messageInfo_PodSandbox proto.InternalMessageInfo func (m *PodSandbox) GetId() string { if m != nil { return m.Id } return "" } func (m *PodSandbox) GetMetadata() *PodSandboxMetadata { if m != nil { return m.Metadata } return nil } func (m *PodSandbox) GetState() PodSandboxState { if m != nil { return m.State } return PodSandboxState_SANDBOX_READY } func (m *PodSandbox) GetCreatedAt() int64 { if m != nil { return m.CreatedAt } return 0 } func (m *PodSandbox) GetLabels() map[string]string { if m != nil { return m.Labels } return nil } func (m *PodSandbox) GetAnnotations() map[string]string { if m != nil { return m.Annotations } return nil } func (m *PodSandbox) GetRuntimeHandler() string { if m != nil { return m.RuntimeHandler } return "" } type ListPodSandboxResponse struct { // List of PodSandboxes. Items []*PodSandbox `protobuf:"bytes,1,rep,name=items,proto3" json:"items,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListPodSandboxResponse) Reset() { *m = ListPodSandboxResponse{} } func (*ListPodSandboxResponse) ProtoMessage() {} func (*ListPodSandboxResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{31} } func (m *ListPodSandboxResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListPodSandboxResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListPodSandboxResponse.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 *ListPodSandboxResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ListPodSandboxResponse.Merge(m, src) } func (m *ListPodSandboxResponse) XXX_Size() int { return m.Size() } func (m *ListPodSandboxResponse) XXX_DiscardUnknown() { xxx_messageInfo_ListPodSandboxResponse.DiscardUnknown(m) } var xxx_messageInfo_ListPodSandboxResponse proto.InternalMessageInfo func (m *ListPodSandboxResponse) GetItems() []*PodSandbox { if m != nil { return m.Items } return nil } type PodSandboxStatsRequest struct { // ID of the pod sandbox for which to retrieve stats. PodSandboxId string `protobuf:"bytes,1,opt,name=pod_sandbox_id,json=podSandboxId,proto3" json:"pod_sandbox_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PodSandboxStatsRequest) Reset() { *m = PodSandboxStatsRequest{} } func (*PodSandboxStatsRequest) ProtoMessage() {} func (*PodSandboxStatsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{32} } func (m *PodSandboxStatsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PodSandboxStatsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PodSandboxStatsRequest.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 *PodSandboxStatsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_PodSandboxStatsRequest.Merge(m, src) } func (m *PodSandboxStatsRequest) XXX_Size() int { return m.Size() } func (m *PodSandboxStatsRequest) XXX_DiscardUnknown() { xxx_messageInfo_PodSandboxStatsRequest.DiscardUnknown(m) } var xxx_messageInfo_PodSandboxStatsRequest proto.InternalMessageInfo func (m *PodSandboxStatsRequest) GetPodSandboxId() string { if m != nil { return m.PodSandboxId } return "" } type PodSandboxStatsResponse struct { Stats *PodSandboxStats `protobuf:"bytes,1,opt,name=stats,proto3" json:"stats,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PodSandboxStatsResponse) Reset() { *m = PodSandboxStatsResponse{} } func (*PodSandboxStatsResponse) ProtoMessage() {} func (*PodSandboxStatsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{33} } func (m *PodSandboxStatsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PodSandboxStatsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PodSandboxStatsResponse.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 *PodSandboxStatsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_PodSandboxStatsResponse.Merge(m, src) } func (m *PodSandboxStatsResponse) XXX_Size() int { return m.Size() } func (m *PodSandboxStatsResponse) XXX_DiscardUnknown() { xxx_messageInfo_PodSandboxStatsResponse.DiscardUnknown(m) } var xxx_messageInfo_PodSandboxStatsResponse proto.InternalMessageInfo func (m *PodSandboxStatsResponse) GetStats() *PodSandboxStats { if m != nil { return m.Stats } return nil } // PodSandboxStatsFilter is used to filter the list of pod sandboxes to retrieve stats for. // All those fields are combined with 'AND'. type PodSandboxStatsFilter struct { // ID of the pod sandbox. Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` // LabelSelector to select matches. // Only api.MatchLabels is supported for now and the requirements // are ANDed. MatchExpressions is not supported yet. LabelSelector map[string]string `protobuf:"bytes,2,rep,name=label_selector,json=labelSelector,proto3" json:"label_selector,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:"-"` } func (m *PodSandboxStatsFilter) Reset() { *m = PodSandboxStatsFilter{} } func (*PodSandboxStatsFilter) ProtoMessage() {} func (*PodSandboxStatsFilter) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{34} } func (m *PodSandboxStatsFilter) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PodSandboxStatsFilter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PodSandboxStatsFilter.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 *PodSandboxStatsFilter) XXX_Merge(src proto.Message) { xxx_messageInfo_PodSandboxStatsFilter.Merge(m, src) } func (m *PodSandboxStatsFilter) XXX_Size() int { return m.Size() } func (m *PodSandboxStatsFilter) XXX_DiscardUnknown() { xxx_messageInfo_PodSandboxStatsFilter.DiscardUnknown(m) } var xxx_messageInfo_PodSandboxStatsFilter proto.InternalMessageInfo func (m *PodSandboxStatsFilter) GetId() string { if m != nil { return m.Id } return "" } func (m *PodSandboxStatsFilter) GetLabelSelector() map[string]string { if m != nil { return m.LabelSelector } return nil } type ListPodSandboxStatsRequest struct { // Filter for the list request. Filter *PodSandboxStatsFilter `protobuf:"bytes,1,opt,name=filter,proto3" json:"filter,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListPodSandboxStatsRequest) Reset() { *m = ListPodSandboxStatsRequest{} } func (*ListPodSandboxStatsRequest) ProtoMessage() {} func (*ListPodSandboxStatsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{35} } func (m *ListPodSandboxStatsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListPodSandboxStatsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListPodSandboxStatsRequest.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 *ListPodSandboxStatsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ListPodSandboxStatsRequest.Merge(m, src) } func (m *ListPodSandboxStatsRequest) XXX_Size() int { return m.Size() } func (m *ListPodSandboxStatsRequest) XXX_DiscardUnknown() { xxx_messageInfo_ListPodSandboxStatsRequest.DiscardUnknown(m) } var xxx_messageInfo_ListPodSandboxStatsRequest proto.InternalMessageInfo func (m *ListPodSandboxStatsRequest) GetFilter() *PodSandboxStatsFilter { if m != nil { return m.Filter } return nil } type ListPodSandboxStatsResponse struct { // Stats of the pod sandbox. Stats []*PodSandboxStats `protobuf:"bytes,1,rep,name=stats,proto3" json:"stats,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListPodSandboxStatsResponse) Reset() { *m = ListPodSandboxStatsResponse{} } func (*ListPodSandboxStatsResponse) ProtoMessage() {} func (*ListPodSandboxStatsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{36} } func (m *ListPodSandboxStatsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListPodSandboxStatsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListPodSandboxStatsResponse.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 *ListPodSandboxStatsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ListPodSandboxStatsResponse.Merge(m, src) } func (m *ListPodSandboxStatsResponse) XXX_Size() int { return m.Size() } func (m *ListPodSandboxStatsResponse) XXX_DiscardUnknown() { xxx_messageInfo_ListPodSandboxStatsResponse.DiscardUnknown(m) } var xxx_messageInfo_ListPodSandboxStatsResponse proto.InternalMessageInfo func (m *ListPodSandboxStatsResponse) GetStats() []*PodSandboxStats { if m != nil { return m.Stats } return nil } // PodSandboxAttributes provides basic information of the pod sandbox. type PodSandboxAttributes struct { // ID of the pod sandbox. Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` // Metadata of the pod sandbox. Metadata *PodSandboxMetadata `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"` // Key-value pairs that may be used to scope and select individual resources. Labels map[string]string `protobuf:"bytes,3,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // Unstructured key-value map holding arbitrary metadata. // Annotations MUST NOT be altered by the runtime; the value of this field // MUST be identical to that of the corresponding PodSandboxStatus used to // instantiate the PodSandbox this status represents. Annotations map[string]string `protobuf:"bytes,4,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:"-"` } func (m *PodSandboxAttributes) Reset() { *m = PodSandboxAttributes{} } func (*PodSandboxAttributes) ProtoMessage() {} func (*PodSandboxAttributes) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{37} } func (m *PodSandboxAttributes) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PodSandboxAttributes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PodSandboxAttributes.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 *PodSandboxAttributes) XXX_Merge(src proto.Message) { xxx_messageInfo_PodSandboxAttributes.Merge(m, src) } func (m *PodSandboxAttributes) XXX_Size() int { return m.Size() } func (m *PodSandboxAttributes) XXX_DiscardUnknown() { xxx_messageInfo_PodSandboxAttributes.DiscardUnknown(m) } var xxx_messageInfo_PodSandboxAttributes proto.InternalMessageInfo func (m *PodSandboxAttributes) GetId() string { if m != nil { return m.Id } return "" } func (m *PodSandboxAttributes) GetMetadata() *PodSandboxMetadata { if m != nil { return m.Metadata } return nil } func (m *PodSandboxAttributes) GetLabels() map[string]string { if m != nil { return m.Labels } return nil } func (m *PodSandboxAttributes) GetAnnotations() map[string]string { if m != nil { return m.Annotations } return nil } // PodSandboxStats provides the resource usage statistics for a pod. // The linux or windows field will be populated depending on the platform. type PodSandboxStats struct { // Information of the pod. Attributes *PodSandboxAttributes `protobuf:"bytes,1,opt,name=attributes,proto3" json:"attributes,omitempty"` // Stats from linux. Linux *LinuxPodSandboxStats `protobuf:"bytes,2,opt,name=linux,proto3" json:"linux,omitempty"` // Stats from windows. Windows *WindowsPodSandboxStats `protobuf:"bytes,3,opt,name=windows,proto3" json:"windows,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PodSandboxStats) Reset() { *m = PodSandboxStats{} } func (*PodSandboxStats) ProtoMessage() {} func (*PodSandboxStats) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{38} } func (m *PodSandboxStats) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PodSandboxStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PodSandboxStats.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 *PodSandboxStats) XXX_Merge(src proto.Message) { xxx_messageInfo_PodSandboxStats.Merge(m, src) } func (m *PodSandboxStats) XXX_Size() int { return m.Size() } func (m *PodSandboxStats) XXX_DiscardUnknown() { xxx_messageInfo_PodSandboxStats.DiscardUnknown(m) } var xxx_messageInfo_PodSandboxStats proto.InternalMessageInfo func (m *PodSandboxStats) GetAttributes() *PodSandboxAttributes { if m != nil { return m.Attributes } return nil } func (m *PodSandboxStats) GetLinux() *LinuxPodSandboxStats { if m != nil { return m.Linux } return nil } func (m *PodSandboxStats) GetWindows() *WindowsPodSandboxStats { if m != nil { return m.Windows } return nil } // LinuxPodSandboxStats provides the resource usage statistics for a pod sandbox on linux. type LinuxPodSandboxStats struct { // CPU usage gathered for the pod sandbox. Cpu *CpuUsage `protobuf:"bytes,1,opt,name=cpu,proto3" json:"cpu,omitempty"` // Memory usage gathered for the pod sandbox. Memory *MemoryUsage `protobuf:"bytes,2,opt,name=memory,proto3" json:"memory,omitempty"` // Network usage gathered for the pod sandbox Network *NetworkUsage `protobuf:"bytes,3,opt,name=network,proto3" json:"network,omitempty"` // Stats pertaining to processes in the pod sandbox. Process *ProcessUsage `protobuf:"bytes,4,opt,name=process,proto3" json:"process,omitempty"` // Stats of containers in the measured pod sandbox. Containers []*ContainerStats `protobuf:"bytes,5,rep,name=containers,proto3" json:"containers,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *LinuxPodSandboxStats) Reset() { *m = LinuxPodSandboxStats{} } func (*LinuxPodSandboxStats) ProtoMessage() {} func (*LinuxPodSandboxStats) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{39} } func (m *LinuxPodSandboxStats) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *LinuxPodSandboxStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_LinuxPodSandboxStats.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 *LinuxPodSandboxStats) XXX_Merge(src proto.Message) { xxx_messageInfo_LinuxPodSandboxStats.Merge(m, src) } func (m *LinuxPodSandboxStats) XXX_Size() int { return m.Size() } func (m *LinuxPodSandboxStats) XXX_DiscardUnknown() { xxx_messageInfo_LinuxPodSandboxStats.DiscardUnknown(m) } var xxx_messageInfo_LinuxPodSandboxStats proto.InternalMessageInfo func (m *LinuxPodSandboxStats) GetCpu() *CpuUsage { if m != nil { return m.Cpu } return nil } func (m *LinuxPodSandboxStats) GetMemory() *MemoryUsage { if m != nil { return m.Memory } return nil } func (m *LinuxPodSandboxStats) GetNetwork() *NetworkUsage { if m != nil { return m.Network } return nil } func (m *LinuxPodSandboxStats) GetProcess() *ProcessUsage { if m != nil { return m.Process } return nil } func (m *LinuxPodSandboxStats) GetContainers() []*ContainerStats { if m != nil { return m.Containers } return nil } // WindowsPodSandboxStats provides the resource usage statistics for a pod sandbox on windows type WindowsPodSandboxStats struct { // CPU usage gathered for the pod sandbox. Cpu *WindowsCpuUsage `protobuf:"bytes,1,opt,name=cpu,proto3" json:"cpu,omitempty"` // Memory usage gathered for the pod sandbox. Memory *WindowsMemoryUsage `protobuf:"bytes,2,opt,name=memory,proto3" json:"memory,omitempty"` // Network usage gathered for the pod sandbox Network *WindowsNetworkUsage `protobuf:"bytes,3,opt,name=network,proto3" json:"network,omitempty"` // Stats pertaining to processes in the pod sandbox. Process *WindowsProcessUsage `protobuf:"bytes,4,opt,name=process,proto3" json:"process,omitempty"` // Stats of containers in the measured pod sandbox. Containers []*WindowsContainerStats `protobuf:"bytes,5,rep,name=containers,proto3" json:"containers,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WindowsPodSandboxStats) Reset() { *m = WindowsPodSandboxStats{} } func (*WindowsPodSandboxStats) ProtoMessage() {} func (*WindowsPodSandboxStats) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{40} } func (m *WindowsPodSandboxStats) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WindowsPodSandboxStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WindowsPodSandboxStats.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 *WindowsPodSandboxStats) XXX_Merge(src proto.Message) { xxx_messageInfo_WindowsPodSandboxStats.Merge(m, src) } func (m *WindowsPodSandboxStats) XXX_Size() int { return m.Size() } func (m *WindowsPodSandboxStats) XXX_DiscardUnknown() { xxx_messageInfo_WindowsPodSandboxStats.DiscardUnknown(m) } var xxx_messageInfo_WindowsPodSandboxStats proto.InternalMessageInfo func (m *WindowsPodSandboxStats) GetCpu() *WindowsCpuUsage { if m != nil { return m.Cpu } return nil } func (m *WindowsPodSandboxStats) GetMemory() *WindowsMemoryUsage { if m != nil { return m.Memory } return nil } func (m *WindowsPodSandboxStats) GetNetwork() *WindowsNetworkUsage { if m != nil { return m.Network } return nil } func (m *WindowsPodSandboxStats) GetProcess() *WindowsProcessUsage { if m != nil { return m.Process } return nil } func (m *WindowsPodSandboxStats) GetContainers() []*WindowsContainerStats { if m != nil { return m.Containers } return nil } // NetworkUsage contains data about network resources. type NetworkUsage 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"` // Stats for the default network interface. DefaultInterface *NetworkInterfaceUsage `protobuf:"bytes,2,opt,name=default_interface,json=defaultInterface,proto3" json:"default_interface,omitempty"` // Stats for all found network interfaces, excluding the default. Interfaces []*NetworkInterfaceUsage `protobuf:"bytes,3,rep,name=interfaces,proto3" json:"interfaces,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *NetworkUsage) Reset() { *m = NetworkUsage{} } func (*NetworkUsage) ProtoMessage() {} func (*NetworkUsage) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{41} } func (m *NetworkUsage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *NetworkUsage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_NetworkUsage.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 *NetworkUsage) XXX_Merge(src proto.Message) { xxx_messageInfo_NetworkUsage.Merge(m, src) } func (m *NetworkUsage) XXX_Size() int { return m.Size() } func (m *NetworkUsage) XXX_DiscardUnknown() { xxx_messageInfo_NetworkUsage.DiscardUnknown(m) } var xxx_messageInfo_NetworkUsage proto.InternalMessageInfo func (m *NetworkUsage) GetTimestamp() int64 { if m != nil { return m.Timestamp } return 0 } func (m *NetworkUsage) GetDefaultInterface() *NetworkInterfaceUsage { if m != nil { return m.DefaultInterface } return nil } func (m *NetworkUsage) GetInterfaces() []*NetworkInterfaceUsage { if m != nil { return m.Interfaces } return nil } // WindowsNetworkUsage contains data about network resources specific to Windows. type WindowsNetworkUsage 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"` // Stats for the default network interface. DefaultInterface *WindowsNetworkInterfaceUsage `protobuf:"bytes,2,opt,name=default_interface,json=defaultInterface,proto3" json:"default_interface,omitempty"` // Stats for all found network interfaces, excluding the default. Interfaces []*WindowsNetworkInterfaceUsage `protobuf:"bytes,3,rep,name=interfaces,proto3" json:"interfaces,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WindowsNetworkUsage) Reset() { *m = WindowsNetworkUsage{} } func (*WindowsNetworkUsage) ProtoMessage() {} func (*WindowsNetworkUsage) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{42} } func (m *WindowsNetworkUsage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WindowsNetworkUsage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WindowsNetworkUsage.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 *WindowsNetworkUsage) XXX_Merge(src proto.Message) { xxx_messageInfo_WindowsNetworkUsage.Merge(m, src) } func (m *WindowsNetworkUsage) XXX_Size() int { return m.Size() } func (m *WindowsNetworkUsage) XXX_DiscardUnknown() { xxx_messageInfo_WindowsNetworkUsage.DiscardUnknown(m) } var xxx_messageInfo_WindowsNetworkUsage proto.InternalMessageInfo func (m *WindowsNetworkUsage) GetTimestamp() int64 { if m != nil { return m.Timestamp } return 0 } func (m *WindowsNetworkUsage) GetDefaultInterface() *WindowsNetworkInterfaceUsage { if m != nil { return m.DefaultInterface } return nil } func (m *WindowsNetworkUsage) GetInterfaces() []*WindowsNetworkInterfaceUsage { if m != nil { return m.Interfaces } return nil } // NetworkInterfaceUsage contains resource value data about a network interface. type NetworkInterfaceUsage struct { // The name of the network interface. Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` // Cumulative count of bytes received. RxBytes *UInt64Value `protobuf:"bytes,2,opt,name=rx_bytes,json=rxBytes,proto3" json:"rx_bytes,omitempty"` // Cumulative count of receive errors encountered. RxErrors *UInt64Value `protobuf:"bytes,3,opt,name=rx_errors,json=rxErrors,proto3" json:"rx_errors,omitempty"` // Cumulative count of bytes transmitted. TxBytes *UInt64Value `protobuf:"bytes,4,opt,name=tx_bytes,json=txBytes,proto3" json:"tx_bytes,omitempty"` // Cumulative count of transmit errors encountered. TxErrors *UInt64Value `protobuf:"bytes,5,opt,name=tx_errors,json=txErrors,proto3" json:"tx_errors,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *NetworkInterfaceUsage) Reset() { *m = NetworkInterfaceUsage{} } func (*NetworkInterfaceUsage) ProtoMessage() {} func (*NetworkInterfaceUsage) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{43} } func (m *NetworkInterfaceUsage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *NetworkInterfaceUsage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_NetworkInterfaceUsage.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 *NetworkInterfaceUsage) XXX_Merge(src proto.Message) { xxx_messageInfo_NetworkInterfaceUsage.Merge(m, src) } func (m *NetworkInterfaceUsage) XXX_Size() int { return m.Size() } func (m *NetworkInterfaceUsage) XXX_DiscardUnknown() { xxx_messageInfo_NetworkInterfaceUsage.DiscardUnknown(m) } var xxx_messageInfo_NetworkInterfaceUsage proto.InternalMessageInfo func (m *NetworkInterfaceUsage) GetName() string { if m != nil { return m.Name } return "" } func (m *NetworkInterfaceUsage) GetRxBytes() *UInt64Value { if m != nil { return m.RxBytes } return nil } func (m *NetworkInterfaceUsage) GetRxErrors() *UInt64Value { if m != nil { return m.RxErrors } return nil } func (m *NetworkInterfaceUsage) GetTxBytes() *UInt64Value { if m != nil { return m.TxBytes } return nil } func (m *NetworkInterfaceUsage) GetTxErrors() *UInt64Value { if m != nil { return m.TxErrors } return nil } // WindowsNetworkInterfaceUsage contains resource value data about a network interface specific for Windows. type WindowsNetworkInterfaceUsage struct { // The name of the network interface. Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` // Cumulative count of bytes received. RxBytes *UInt64Value `protobuf:"bytes,2,opt,name=rx_bytes,json=rxBytes,proto3" json:"rx_bytes,omitempty"` // Cumulative count of receive errors encountered. RxPacketsDropped *UInt64Value `protobuf:"bytes,3,opt,name=rx_packets_dropped,json=rxPacketsDropped,proto3" json:"rx_packets_dropped,omitempty"` // Cumulative count of bytes transmitted. TxBytes *UInt64Value `protobuf:"bytes,4,opt,name=tx_bytes,json=txBytes,proto3" json:"tx_bytes,omitempty"` // Cumulative count of transmit errors encountered. TxPacketsDropped *UInt64Value `protobuf:"bytes,5,opt,name=tx_packets_dropped,json=txPacketsDropped,proto3" json:"tx_packets_dropped,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WindowsNetworkInterfaceUsage) Reset() { *m = WindowsNetworkInterfaceUsage{} } func (*WindowsNetworkInterfaceUsage) ProtoMessage() {} func (*WindowsNetworkInterfaceUsage) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{44} } func (m *WindowsNetworkInterfaceUsage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WindowsNetworkInterfaceUsage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WindowsNetworkInterfaceUsage.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 *WindowsNetworkInterfaceUsage) XXX_Merge(src proto.Message) { xxx_messageInfo_WindowsNetworkInterfaceUsage.Merge(m, src) } func (m *WindowsNetworkInterfaceUsage) XXX_Size() int { return m.Size() } func (m *WindowsNetworkInterfaceUsage) XXX_DiscardUnknown() { xxx_messageInfo_WindowsNetworkInterfaceUsage.DiscardUnknown(m) } var xxx_messageInfo_WindowsNetworkInterfaceUsage proto.InternalMessageInfo func (m *WindowsNetworkInterfaceUsage) GetName() string { if m != nil { return m.Name } return "" } func (m *WindowsNetworkInterfaceUsage) GetRxBytes() *UInt64Value { if m != nil { return m.RxBytes } return nil } func (m *WindowsNetworkInterfaceUsage) GetRxPacketsDropped() *UInt64Value { if m != nil { return m.RxPacketsDropped } return nil } func (m *WindowsNetworkInterfaceUsage) GetTxBytes() *UInt64Value { if m != nil { return m.TxBytes } return nil } func (m *WindowsNetworkInterfaceUsage) GetTxPacketsDropped() *UInt64Value { if m != nil { return m.TxPacketsDropped } return nil } // ProcessUsage are stats pertaining to processes. type ProcessUsage 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"` // Number of processes. ProcessCount *UInt64Value `protobuf:"bytes,2,opt,name=process_count,json=processCount,proto3" json:"process_count,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ProcessUsage) Reset() { *m = ProcessUsage{} } func (*ProcessUsage) ProtoMessage() {} func (*ProcessUsage) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{45} } func (m *ProcessUsage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ProcessUsage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ProcessUsage.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 *ProcessUsage) XXX_Merge(src proto.Message) { xxx_messageInfo_ProcessUsage.Merge(m, src) } func (m *ProcessUsage) XXX_Size() int { return m.Size() } func (m *ProcessUsage) XXX_DiscardUnknown() { xxx_messageInfo_ProcessUsage.DiscardUnknown(m) } var xxx_messageInfo_ProcessUsage proto.InternalMessageInfo func (m *ProcessUsage) GetTimestamp() int64 { if m != nil { return m.Timestamp } return 0 } func (m *ProcessUsage) GetProcessCount() *UInt64Value { if m != nil { return m.ProcessCount } return nil } // WindowsProcessUsage are stats pertaining to processes specific to Windows. type WindowsProcessUsage 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"` // Number of processes. ProcessCount *UInt64Value `protobuf:"bytes,2,opt,name=process_count,json=processCount,proto3" json:"process_count,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WindowsProcessUsage) Reset() { *m = WindowsProcessUsage{} } func (*WindowsProcessUsage) ProtoMessage() {} func (*WindowsProcessUsage) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{46} } func (m *WindowsProcessUsage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WindowsProcessUsage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WindowsProcessUsage.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 *WindowsProcessUsage) XXX_Merge(src proto.Message) { xxx_messageInfo_WindowsProcessUsage.Merge(m, src) } func (m *WindowsProcessUsage) XXX_Size() int { return m.Size() } func (m *WindowsProcessUsage) XXX_DiscardUnknown() { xxx_messageInfo_WindowsProcessUsage.DiscardUnknown(m) } var xxx_messageInfo_WindowsProcessUsage proto.InternalMessageInfo func (m *WindowsProcessUsage) GetTimestamp() int64 { if m != nil { return m.Timestamp } return 0 } func (m *WindowsProcessUsage) GetProcessCount() *UInt64Value { if m != nil { return m.ProcessCount } return nil } // ImageSpec is an internal representation of an image. type ImageSpec struct { // Container's Image field (e.g. imageID or imageDigest). Image string `protobuf:"bytes,1,opt,name=image,proto3" json:"image,omitempty"` // 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"` // 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{} } func (*ImageSpec) ProtoMessage() {} func (*ImageSpec) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{47} } func (m *ImageSpec) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ImageSpec) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ImageSpec.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 *ImageSpec) XXX_Merge(src proto.Message) { xxx_messageInfo_ImageSpec.Merge(m, src) } func (m *ImageSpec) XXX_Size() int { return m.Size() } func (m *ImageSpec) XXX_DiscardUnknown() { xxx_messageInfo_ImageSpec.DiscardUnknown(m) } var xxx_messageInfo_ImageSpec proto.InternalMessageInfo func (m *ImageSpec) GetImage() string { if m != nil { return m.Image } return "" } func (m *ImageSpec) GetAnnotations() map[string]string { if m != nil { return m.Annotations } 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"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *KeyValue) Reset() { *m = KeyValue{} } func (*KeyValue) ProtoMessage() {} func (*KeyValue) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{48} } func (m *KeyValue) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *KeyValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_KeyValue.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 *KeyValue) XXX_Merge(src proto.Message) { xxx_messageInfo_KeyValue.Merge(m, src) } func (m *KeyValue) XXX_Size() int { return m.Size() } func (m *KeyValue) XXX_DiscardUnknown() { xxx_messageInfo_KeyValue.DiscardUnknown(m) } var xxx_messageInfo_KeyValue proto.InternalMessageInfo func (m *KeyValue) GetKey() string { if m != nil { return m.Key } return "" } func (m *KeyValue) GetValue() string { if m != nil { return m.Value } return "" } // LinuxContainerResources specifies Linux specific configuration for // resources. type LinuxContainerResources struct { // CPU CFS (Completely Fair Scheduler) period. Default: 0 (not specified). CpuPeriod int64 `protobuf:"varint,1,opt,name=cpu_period,json=cpuPeriod,proto3" json:"cpu_period,omitempty"` // CPU CFS (Completely Fair Scheduler) quota. Default: 0 (not specified). CpuQuota int64 `protobuf:"varint,2,opt,name=cpu_quota,json=cpuQuota,proto3" json:"cpu_quota,omitempty"` // CPU shares (relative weight vs. other containers). Default: 0 (not specified). CpuShares int64 `protobuf:"varint,3,opt,name=cpu_shares,json=cpuShares,proto3" json:"cpu_shares,omitempty"` // Memory limit in bytes. Default: 0 (not specified). MemoryLimitInBytes int64 `protobuf:"varint,4,opt,name=memory_limit_in_bytes,json=memoryLimitInBytes,proto3" json:"memory_limit_in_bytes,omitempty"` // OOMScoreAdj adjusts the oom-killer score. Default: 0 (not specified). OomScoreAdj int64 `protobuf:"varint,5,opt,name=oom_score_adj,json=oomScoreAdj,proto3" json:"oom_score_adj,omitempty"` // CpusetCpus constrains the allowed set of logical CPUs. Default: "" (not specified). CpusetCpus string `protobuf:"bytes,6,opt,name=cpuset_cpus,json=cpusetCpus,proto3" json:"cpuset_cpus,omitempty"` // CpusetMems constrains the allowed set of memory nodes. Default: "" (not specified). CpusetMems string `protobuf:"bytes,7,opt,name=cpuset_mems,json=cpusetMems,proto3" json:"cpuset_mems,omitempty"` // List of HugepageLimits to limit the HugeTLB usage of container per page size. Default: nil (not specified). HugepageLimits []*HugepageLimit `protobuf:"bytes,8,rep,name=hugepage_limits,json=hugepageLimits,proto3" json:"hugepage_limits,omitempty"` // Unified resources for cgroup v2. Default: nil (not specified). // Each key/value in the map refers to the cgroup v2. // e.g. "memory.max": "6937202688" or "io.weight": "default 100". Unified map[string]string `protobuf:"bytes,9,rep,name=unified,proto3" json:"unified,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // Memory swap limit in bytes. Default 0 (not specified). MemorySwapLimitInBytes int64 `protobuf:"varint,10,opt,name=memory_swap_limit_in_bytes,json=memorySwapLimitInBytes,proto3" json:"memory_swap_limit_in_bytes,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *LinuxContainerResources) Reset() { *m = LinuxContainerResources{} } func (*LinuxContainerResources) ProtoMessage() {} func (*LinuxContainerResources) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{49} } func (m *LinuxContainerResources) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *LinuxContainerResources) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_LinuxContainerResources.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 *LinuxContainerResources) XXX_Merge(src proto.Message) { xxx_messageInfo_LinuxContainerResources.Merge(m, src) } func (m *LinuxContainerResources) XXX_Size() int { return m.Size() } func (m *LinuxContainerResources) XXX_DiscardUnknown() { xxx_messageInfo_LinuxContainerResources.DiscardUnknown(m) } var xxx_messageInfo_LinuxContainerResources proto.InternalMessageInfo func (m *LinuxContainerResources) GetCpuPeriod() int64 { if m != nil { return m.CpuPeriod } return 0 } func (m *LinuxContainerResources) GetCpuQuota() int64 { if m != nil { return m.CpuQuota } return 0 } func (m *LinuxContainerResources) GetCpuShares() int64 { if m != nil { return m.CpuShares } return 0 } func (m *LinuxContainerResources) GetMemoryLimitInBytes() int64 { if m != nil { return m.MemoryLimitInBytes } return 0 } func (m *LinuxContainerResources) GetOomScoreAdj() int64 { if m != nil { return m.OomScoreAdj } return 0 } func (m *LinuxContainerResources) GetCpusetCpus() string { if m != nil { return m.CpusetCpus } return "" } func (m *LinuxContainerResources) GetCpusetMems() string { if m != nil { return m.CpusetMems } return "" } func (m *LinuxContainerResources) GetHugepageLimits() []*HugepageLimit { if m != nil { return m.HugepageLimits } return nil } func (m *LinuxContainerResources) GetUnified() map[string]string { if m != nil { return m.Unified } return nil } func (m *LinuxContainerResources) GetMemorySwapLimitInBytes() int64 { if m != nil { return m.MemorySwapLimitInBytes } return 0 } // HugepageLimit corresponds to the file`hugetlb..limit_in_byte` in container level cgroup. // For example, `PageSize=1GB`, `Limit=1073741824` means setting `1073741824` bytes to hugetlb.1GB.limit_in_bytes. type HugepageLimit struct { // The value of PageSize has the format B (2MB, 1GB), // and must match the of the corresponding control file found in `hugetlb..limit_in_bytes`. // The values of are intended to be parsed using base 1024("1KB" = 1024, "1MB" = 1048576, etc). PageSize string `protobuf:"bytes,1,opt,name=page_size,json=pageSize,proto3" json:"page_size,omitempty"` // limit in bytes of hugepagesize HugeTLB usage. Limit uint64 `protobuf:"varint,2,opt,name=limit,proto3" json:"limit,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *HugepageLimit) Reset() { *m = HugepageLimit{} } func (*HugepageLimit) ProtoMessage() {} func (*HugepageLimit) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{50} } func (m *HugepageLimit) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *HugepageLimit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_HugepageLimit.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 *HugepageLimit) XXX_Merge(src proto.Message) { xxx_messageInfo_HugepageLimit.Merge(m, src) } func (m *HugepageLimit) XXX_Size() int { return m.Size() } func (m *HugepageLimit) XXX_DiscardUnknown() { xxx_messageInfo_HugepageLimit.DiscardUnknown(m) } var xxx_messageInfo_HugepageLimit proto.InternalMessageInfo func (m *HugepageLimit) GetPageSize() string { if m != nil { return m.PageSize } return "" } func (m *HugepageLimit) GetLimit() uint64 { if m != nil { return m.Limit } return 0 } // SELinuxOption are the labels to be applied to the container. type SELinuxOption struct { User string `protobuf:"bytes,1,opt,name=user,proto3" json:"user,omitempty"` Role string `protobuf:"bytes,2,opt,name=role,proto3" json:"role,omitempty"` Type string `protobuf:"bytes,3,opt,name=type,proto3" json:"type,omitempty"` Level string `protobuf:"bytes,4,opt,name=level,proto3" json:"level,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *SELinuxOption) Reset() { *m = SELinuxOption{} } func (*SELinuxOption) ProtoMessage() {} func (*SELinuxOption) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{51} } func (m *SELinuxOption) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *SELinuxOption) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_SELinuxOption.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 *SELinuxOption) XXX_Merge(src proto.Message) { xxx_messageInfo_SELinuxOption.Merge(m, src) } func (m *SELinuxOption) XXX_Size() int { return m.Size() } func (m *SELinuxOption) XXX_DiscardUnknown() { xxx_messageInfo_SELinuxOption.DiscardUnknown(m) } var xxx_messageInfo_SELinuxOption proto.InternalMessageInfo func (m *SELinuxOption) GetUser() string { if m != nil { return m.User } return "" } func (m *SELinuxOption) GetRole() string { if m != nil { return m.Role } return "" } func (m *SELinuxOption) GetType() string { if m != nil { return m.Type } return "" } func (m *SELinuxOption) GetLevel() string { if m != nil { return m.Level } return "" } // Capability contains the container capabilities to add or drop // Dropping a capability will drop it from all sets. // If a capability is added to only the add_capabilities list then it gets added to permitted, // inheritable, effective and bounding sets, i.e. all sets except the ambient set. // If a capability is added to only the add_ambient_capabilities list then it gets added to all sets, i.e permitted // inheritable, effective, bounding and ambient sets. // If a capability is added to add_capabilities and add_ambient_capabilities lists then it gets added to all sets, i.e. // permitted, inheritable, effective, bounding and ambient sets. type Capability struct { // List of capabilities to add. AddCapabilities []string `protobuf:"bytes,1,rep,name=add_capabilities,json=addCapabilities,proto3" json:"add_capabilities,omitempty"` // List of capabilities to drop. DropCapabilities []string `protobuf:"bytes,2,rep,name=drop_capabilities,json=dropCapabilities,proto3" json:"drop_capabilities,omitempty"` // List of ambient capabilities to add. AddAmbientCapabilities []string `protobuf:"bytes,3,rep,name=add_ambient_capabilities,json=addAmbientCapabilities,proto3" json:"add_ambient_capabilities,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Capability) Reset() { *m = Capability{} } func (*Capability) ProtoMessage() {} func (*Capability) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{52} } func (m *Capability) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Capability) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Capability.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 *Capability) XXX_Merge(src proto.Message) { xxx_messageInfo_Capability.Merge(m, src) } func (m *Capability) XXX_Size() int { return m.Size() } func (m *Capability) XXX_DiscardUnknown() { xxx_messageInfo_Capability.DiscardUnknown(m) } var xxx_messageInfo_Capability proto.InternalMessageInfo func (m *Capability) GetAddCapabilities() []string { if m != nil { return m.AddCapabilities } return nil } func (m *Capability) GetDropCapabilities() []string { if m != nil { return m.DropCapabilities } return nil } func (m *Capability) GetAddAmbientCapabilities() []string { if m != nil { return m.AddAmbientCapabilities } return nil } // LinuxContainerSecurityContext holds linux security configuration that will be applied to a container. type LinuxContainerSecurityContext struct { // Capabilities to add or drop. Capabilities *Capability `protobuf:"bytes,1,opt,name=capabilities,proto3" json:"capabilities,omitempty"` // If set, run container in privileged mode. // Privileged mode is incompatible with the following options. If // privileged is set, the following features MAY have no effect: // 1. capabilities // 2. selinux_options // 4. seccomp // 5. apparmor // // Privileged mode implies the following specific options are applied: // 1. All capabilities are added. // 2. Sensitive paths, such as kernel module paths within sysfs, are not masked. // 3. Any sysfs and procfs mounts are mounted RW. // 4. AppArmor confinement is not applied. // 5. Seccomp restrictions are not applied. // 6. The device cgroup does not restrict access to any devices. // 7. All devices from the host's /dev are available within the container. // 8. SELinux restrictions are not applied (e.g. label=disabled). Privileged bool `protobuf:"varint,2,opt,name=privileged,proto3" json:"privileged,omitempty"` // Configurations for the container's namespaces. // Only used if the container uses namespace for isolation. NamespaceOptions *NamespaceOption `protobuf:"bytes,3,opt,name=namespace_options,json=namespaceOptions,proto3" json:"namespace_options,omitempty"` // SELinux context to be optionally applied. SelinuxOptions *SELinuxOption `protobuf:"bytes,4,opt,name=selinux_options,json=selinuxOptions,proto3" json:"selinux_options,omitempty"` // UID to run the container process as. Only one of run_as_user and // run_as_username can be specified at a time. RunAsUser *Int64Value `protobuf:"bytes,5,opt,name=run_as_user,json=runAsUser,proto3" json:"run_as_user,omitempty"` // GID to run the container process as. run_as_group should only be specified // when run_as_user or run_as_username is specified; otherwise, the runtime // MUST error. RunAsGroup *Int64Value `protobuf:"bytes,12,opt,name=run_as_group,json=runAsGroup,proto3" json:"run_as_group,omitempty"` // User name to run the container process as. If specified, the user MUST // exist in the container image (i.e. in the /etc/passwd inside the image), // and be resolved there by the runtime; otherwise, the runtime MUST error. 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 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"` // masked_paths is a slice of paths that should be masked by the container // runtime, this can be passed directly to the OCI spec. MaskedPaths []string `protobuf:"bytes,13,rep,name=masked_paths,json=maskedPaths,proto3" json:"masked_paths,omitempty"` // readonly_paths is a slice of paths that should be set as readonly by the // container runtime, this can be passed directly to the OCI spec. ReadonlyPaths []string `protobuf:"bytes,14,rep,name=readonly_paths,json=readonlyPaths,proto3" json:"readonly_paths,omitempty"` // Seccomp profile for the container. Seccomp *SecurityProfile `protobuf:"bytes,15,opt,name=seccomp,proto3" json:"seccomp,omitempty"` // AppArmor profile for the container. Apparmor *SecurityProfile `protobuf:"bytes,16,opt,name=apparmor,proto3" json:"apparmor,omitempty"` // AppArmor profile for the container, candidate values are: // - runtime/default: equivalent to not specifying a profile. // - unconfined: no profiles are loaded // - localhost/: profile loaded on the node // (localhost) by name. The possible profile names are detailed at // https://gitlab.com/apparmor/apparmor/-/wikis/AppArmor_Core_Policy_Reference ApparmorProfile string `protobuf:"bytes,9,opt,name=apparmor_profile,json=apparmorProfile,proto3" json:"apparmor_profile,omitempty"` // Deprecated: Do not use. // Seccomp profile for the container, candidate values are: // - runtime/default: the default profile for the container runtime // - unconfined: unconfined profile, ie, no seccomp sandboxing // - localhost/: the profile installed on the node. // is the full path of the profile. // // Default: "", which is identical with unconfined. SeccompProfilePath string `protobuf:"bytes,10,opt,name=seccomp_profile_path,json=seccompProfilePath,proto3" json:"seccomp_profile_path,omitempty"` // Deprecated: Do not use. XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *LinuxContainerSecurityContext) Reset() { *m = LinuxContainerSecurityContext{} } func (*LinuxContainerSecurityContext) ProtoMessage() {} func (*LinuxContainerSecurityContext) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{53} } func (m *LinuxContainerSecurityContext) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *LinuxContainerSecurityContext) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_LinuxContainerSecurityContext.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 *LinuxContainerSecurityContext) XXX_Merge(src proto.Message) { xxx_messageInfo_LinuxContainerSecurityContext.Merge(m, src) } func (m *LinuxContainerSecurityContext) XXX_Size() int { return m.Size() } func (m *LinuxContainerSecurityContext) XXX_DiscardUnknown() { xxx_messageInfo_LinuxContainerSecurityContext.DiscardUnknown(m) } var xxx_messageInfo_LinuxContainerSecurityContext proto.InternalMessageInfo func (m *LinuxContainerSecurityContext) GetCapabilities() *Capability { if m != nil { return m.Capabilities } return nil } func (m *LinuxContainerSecurityContext) GetPrivileged() bool { if m != nil { return m.Privileged } return false } func (m *LinuxContainerSecurityContext) GetNamespaceOptions() *NamespaceOption { if m != nil { return m.NamespaceOptions } return nil } func (m *LinuxContainerSecurityContext) GetSelinuxOptions() *SELinuxOption { if m != nil { return m.SelinuxOptions } return nil } func (m *LinuxContainerSecurityContext) GetRunAsUser() *Int64Value { if m != nil { return m.RunAsUser } return nil } func (m *LinuxContainerSecurityContext) GetRunAsGroup() *Int64Value { if m != nil { return m.RunAsGroup } return nil } func (m *LinuxContainerSecurityContext) GetRunAsUsername() string { if m != nil { return m.RunAsUsername } return "" } func (m *LinuxContainerSecurityContext) GetReadonlyRootfs() bool { if m != nil { return m.ReadonlyRootfs } return false } func (m *LinuxContainerSecurityContext) GetSupplementalGroups() []int64 { if m != nil { return m.SupplementalGroups } 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 } return false } func (m *LinuxContainerSecurityContext) GetMaskedPaths() []string { if m != nil { return m.MaskedPaths } return nil } func (m *LinuxContainerSecurityContext) GetReadonlyPaths() []string { if m != nil { return m.ReadonlyPaths } return nil } func (m *LinuxContainerSecurityContext) GetSeccomp() *SecurityProfile { if m != nil { return m.Seccomp } return nil } func (m *LinuxContainerSecurityContext) GetApparmor() *SecurityProfile { if m != nil { return m.Apparmor } return nil } // Deprecated: Do not use. func (m *LinuxContainerSecurityContext) GetApparmorProfile() string { if m != nil { return m.ApparmorProfile } return "" } // Deprecated: Do not use. func (m *LinuxContainerSecurityContext) GetSeccompProfilePath() string { if m != nil { return m.SeccompProfilePath } return "" } // LinuxContainerConfig contains platform-specific configuration for // Linux-based containers. type LinuxContainerConfig struct { // Resources specification for the container. Resources *LinuxContainerResources `protobuf:"bytes,1,opt,name=resources,proto3" json:"resources,omitempty"` // LinuxContainerSecurityContext configuration for the container. SecurityContext *LinuxContainerSecurityContext `protobuf:"bytes,2,opt,name=security_context,json=securityContext,proto3" json:"security_context,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *LinuxContainerConfig) Reset() { *m = LinuxContainerConfig{} } func (*LinuxContainerConfig) ProtoMessage() {} func (*LinuxContainerConfig) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{54} } func (m *LinuxContainerConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *LinuxContainerConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_LinuxContainerConfig.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 *LinuxContainerConfig) XXX_Merge(src proto.Message) { xxx_messageInfo_LinuxContainerConfig.Merge(m, src) } func (m *LinuxContainerConfig) XXX_Size() int { return m.Size() } func (m *LinuxContainerConfig) XXX_DiscardUnknown() { xxx_messageInfo_LinuxContainerConfig.DiscardUnknown(m) } var xxx_messageInfo_LinuxContainerConfig proto.InternalMessageInfo func (m *LinuxContainerConfig) GetResources() *LinuxContainerResources { if m != nil { return m.Resources } return nil } func (m *LinuxContainerConfig) GetSecurityContext() *LinuxContainerSecurityContext { if m != nil { return m.SecurityContext } 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. // Namespaces currently set by the kubelet: POD, NODE Network NamespaceMode `protobuf:"varint,1,opt,name=network,proto3,enum=runtime.v1.NamespaceMode" json:"network,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WindowsNamespaceOption) Reset() { *m = WindowsNamespaceOption{} } func (*WindowsNamespaceOption) ProtoMessage() {} func (*WindowsNamespaceOption) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{56} } func (m *WindowsNamespaceOption) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WindowsNamespaceOption) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WindowsNamespaceOption.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 *WindowsNamespaceOption) XXX_Merge(src proto.Message) { xxx_messageInfo_WindowsNamespaceOption.Merge(m, src) } func (m *WindowsNamespaceOption) XXX_Size() int { return m.Size() } func (m *WindowsNamespaceOption) XXX_DiscardUnknown() { xxx_messageInfo_WindowsNamespaceOption.DiscardUnknown(m) } var xxx_messageInfo_WindowsNamespaceOption proto.InternalMessageInfo func (m *WindowsNamespaceOption) GetNetwork() NamespaceMode { if m != nil { return m.Network } return NamespaceMode_POD } // WindowsSandboxSecurityContext holds platform-specific configurations that will be // applied to a sandbox. // These settings will only apply to the sandbox container. type WindowsSandboxSecurityContext struct { // User name to run the container process as. If specified, the user MUST // exist in the container image and be resolved there by the runtime; // otherwise, the runtime MUST return error. RunAsUsername string `protobuf:"bytes,1,opt,name=run_as_username,json=runAsUsername,proto3" json:"run_as_username,omitempty"` // The contents of the GMSA credential spec to use to run this container. CredentialSpec string `protobuf:"bytes,2,opt,name=credential_spec,json=credentialSpec,proto3" json:"credential_spec,omitempty"` // Indicates whether the container requested to run as a HostProcess container. HostProcess bool `protobuf:"varint,3,opt,name=host_process,json=hostProcess,proto3" json:"host_process,omitempty"` // Configuration for the sandbox's namespaces NamespaceOptions *WindowsNamespaceOption `protobuf:"bytes,4,opt,name=namespace_options,json=namespaceOptions,proto3" json:"namespace_options,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WindowsSandboxSecurityContext) Reset() { *m = WindowsSandboxSecurityContext{} } func (*WindowsSandboxSecurityContext) ProtoMessage() {} func (*WindowsSandboxSecurityContext) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{57} } func (m *WindowsSandboxSecurityContext) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WindowsSandboxSecurityContext) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WindowsSandboxSecurityContext.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 *WindowsSandboxSecurityContext) XXX_Merge(src proto.Message) { xxx_messageInfo_WindowsSandboxSecurityContext.Merge(m, src) } func (m *WindowsSandboxSecurityContext) XXX_Size() int { return m.Size() } func (m *WindowsSandboxSecurityContext) XXX_DiscardUnknown() { xxx_messageInfo_WindowsSandboxSecurityContext.DiscardUnknown(m) } var xxx_messageInfo_WindowsSandboxSecurityContext proto.InternalMessageInfo func (m *WindowsSandboxSecurityContext) GetRunAsUsername() string { if m != nil { return m.RunAsUsername } return "" } func (m *WindowsSandboxSecurityContext) GetCredentialSpec() string { if m != nil { return m.CredentialSpec } return "" } func (m *WindowsSandboxSecurityContext) GetHostProcess() bool { if m != nil { return m.HostProcess } return false } func (m *WindowsSandboxSecurityContext) GetNamespaceOptions() *WindowsNamespaceOption { if m != nil { return m.NamespaceOptions } return nil } // WindowsPodSandboxConfig holds platform-specific configurations for Windows // host platforms and Windows-based containers. type WindowsPodSandboxConfig struct { // WindowsSandboxSecurityContext holds sandbox security attributes. SecurityContext *WindowsSandboxSecurityContext `protobuf:"bytes,1,opt,name=security_context,json=securityContext,proto3" json:"security_context,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WindowsPodSandboxConfig) Reset() { *m = WindowsPodSandboxConfig{} } func (*WindowsPodSandboxConfig) ProtoMessage() {} func (*WindowsPodSandboxConfig) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{58} } func (m *WindowsPodSandboxConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WindowsPodSandboxConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WindowsPodSandboxConfig.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 *WindowsPodSandboxConfig) XXX_Merge(src proto.Message) { xxx_messageInfo_WindowsPodSandboxConfig.Merge(m, src) } func (m *WindowsPodSandboxConfig) XXX_Size() int { return m.Size() } func (m *WindowsPodSandboxConfig) XXX_DiscardUnknown() { xxx_messageInfo_WindowsPodSandboxConfig.DiscardUnknown(m) } var xxx_messageInfo_WindowsPodSandboxConfig proto.InternalMessageInfo func (m *WindowsPodSandboxConfig) GetSecurityContext() *WindowsSandboxSecurityContext { if m != nil { return m.SecurityContext } return nil } // WindowsContainerSecurityContext holds windows security configuration that will be applied to a container. type WindowsContainerSecurityContext struct { // User name to run the container process as. If specified, the user MUST // exist in the container image and be resolved there by the runtime; // otherwise, the runtime MUST return error. RunAsUsername string `protobuf:"bytes,1,opt,name=run_as_username,json=runAsUsername,proto3" json:"run_as_username,omitempty"` // The contents of the GMSA credential spec to use to run this container. CredentialSpec string `protobuf:"bytes,2,opt,name=credential_spec,json=credentialSpec,proto3" json:"credential_spec,omitempty"` // Indicates whether a container is to be run as a HostProcess container. HostProcess bool `protobuf:"varint,3,opt,name=host_process,json=hostProcess,proto3" json:"host_process,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WindowsContainerSecurityContext) Reset() { *m = WindowsContainerSecurityContext{} } func (*WindowsContainerSecurityContext) ProtoMessage() {} func (*WindowsContainerSecurityContext) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{59} } func (m *WindowsContainerSecurityContext) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WindowsContainerSecurityContext) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WindowsContainerSecurityContext.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 *WindowsContainerSecurityContext) XXX_Merge(src proto.Message) { xxx_messageInfo_WindowsContainerSecurityContext.Merge(m, src) } func (m *WindowsContainerSecurityContext) XXX_Size() int { return m.Size() } func (m *WindowsContainerSecurityContext) XXX_DiscardUnknown() { xxx_messageInfo_WindowsContainerSecurityContext.DiscardUnknown(m) } var xxx_messageInfo_WindowsContainerSecurityContext proto.InternalMessageInfo func (m *WindowsContainerSecurityContext) GetRunAsUsername() string { if m != nil { return m.RunAsUsername } return "" } func (m *WindowsContainerSecurityContext) GetCredentialSpec() string { if m != nil { return m.CredentialSpec } return "" } func (m *WindowsContainerSecurityContext) GetHostProcess() bool { if m != nil { return m.HostProcess } return false } // WindowsContainerConfig contains platform-specific configuration for // Windows-based containers. type WindowsContainerConfig struct { // Resources specification for the container. Resources *WindowsContainerResources `protobuf:"bytes,1,opt,name=resources,proto3" json:"resources,omitempty"` // WindowsContainerSecurityContext configuration for the container. SecurityContext *WindowsContainerSecurityContext `protobuf:"bytes,2,opt,name=security_context,json=securityContext,proto3" json:"security_context,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WindowsContainerConfig) Reset() { *m = WindowsContainerConfig{} } func (*WindowsContainerConfig) ProtoMessage() {} func (*WindowsContainerConfig) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{60} } func (m *WindowsContainerConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WindowsContainerConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WindowsContainerConfig.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 *WindowsContainerConfig) XXX_Merge(src proto.Message) { xxx_messageInfo_WindowsContainerConfig.Merge(m, src) } func (m *WindowsContainerConfig) XXX_Size() int { return m.Size() } func (m *WindowsContainerConfig) XXX_DiscardUnknown() { xxx_messageInfo_WindowsContainerConfig.DiscardUnknown(m) } var xxx_messageInfo_WindowsContainerConfig proto.InternalMessageInfo func (m *WindowsContainerConfig) GetResources() *WindowsContainerResources { if m != nil { return m.Resources } return nil } func (m *WindowsContainerConfig) GetSecurityContext() *WindowsContainerSecurityContext { if m != nil { return m.SecurityContext } return nil } // WindowsContainerResources specifies Windows specific configuration for // resources. type WindowsContainerResources struct { // CPU shares (relative weight vs. other containers). Default: 0 (not specified). CpuShares int64 `protobuf:"varint,1,opt,name=cpu_shares,json=cpuShares,proto3" json:"cpu_shares,omitempty"` // Number of CPUs available to the container. Default: 0 (not specified). CpuCount int64 `protobuf:"varint,2,opt,name=cpu_count,json=cpuCount,proto3" json:"cpu_count,omitempty"` // Specifies the portion of processor cycles that this container can use as a percentage times 100. CpuMaximum int64 `protobuf:"varint,3,opt,name=cpu_maximum,json=cpuMaximum,proto3" json:"cpu_maximum,omitempty"` // Memory limit in bytes. Default: 0 (not specified). MemoryLimitInBytes int64 `protobuf:"varint,4,opt,name=memory_limit_in_bytes,json=memoryLimitInBytes,proto3" json:"memory_limit_in_bytes,omitempty"` // Specifies the size of the rootfs / scratch space in bytes to be configured for this container. Default: 0 (not specified). RootfsSizeInBytes int64 `protobuf:"varint,5,opt,name=rootfs_size_in_bytes,json=rootfsSizeInBytes,proto3" json:"rootfs_size_in_bytes,omitempty"` // Optionally specifies the set of CPUs to affinitize for this container. AffinityCpus []*WindowsCpuGroupAffinity `protobuf:"bytes,6,rep,name=affinity_cpus,json=affinityCpus,proto3" json:"affinity_cpus,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WindowsContainerResources) Reset() { *m = WindowsContainerResources{} } func (*WindowsContainerResources) ProtoMessage() {} func (*WindowsContainerResources) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{61} } func (m *WindowsContainerResources) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WindowsContainerResources) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WindowsContainerResources.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 *WindowsContainerResources) XXX_Merge(src proto.Message) { xxx_messageInfo_WindowsContainerResources.Merge(m, src) } func (m *WindowsContainerResources) XXX_Size() int { return m.Size() } func (m *WindowsContainerResources) XXX_DiscardUnknown() { xxx_messageInfo_WindowsContainerResources.DiscardUnknown(m) } var xxx_messageInfo_WindowsContainerResources proto.InternalMessageInfo func (m *WindowsContainerResources) GetCpuShares() int64 { if m != nil { return m.CpuShares } return 0 } func (m *WindowsContainerResources) GetCpuCount() int64 { if m != nil { return m.CpuCount } return 0 } func (m *WindowsContainerResources) GetCpuMaximum() int64 { if m != nil { return m.CpuMaximum } return 0 } func (m *WindowsContainerResources) GetMemoryLimitInBytes() int64 { if m != nil { return m.MemoryLimitInBytes } return 0 } func (m *WindowsContainerResources) GetRootfsSizeInBytes() int64 { if m != nil { return m.RootfsSizeInBytes } return 0 } func (m *WindowsContainerResources) GetAffinityCpus() []*WindowsCpuGroupAffinity { if m != nil { return m.AffinityCpus } return nil } // WindowsCpuGroupAffinity specifies the CPU mask and group to affinitize. // This is similar to the following _GROUP_AFFINITY structure: // https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/miniport/ns-miniport-_group_affinity type WindowsCpuGroupAffinity struct { // CPU mask relative to this CPU group. CpuMask uint64 `protobuf:"varint,1,opt,name=cpu_mask,json=cpuMask,proto3" json:"cpu_mask,omitempty"` // Processor group the mask refers to, as returned by // GetLogicalProcessorInformationEx. CpuGroup uint32 `protobuf:"varint,2,opt,name=cpu_group,json=cpuGroup,proto3" json:"cpu_group,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WindowsCpuGroupAffinity) Reset() { *m = WindowsCpuGroupAffinity{} } func (*WindowsCpuGroupAffinity) ProtoMessage() {} func (*WindowsCpuGroupAffinity) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{62} } func (m *WindowsCpuGroupAffinity) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WindowsCpuGroupAffinity) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WindowsCpuGroupAffinity.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 *WindowsCpuGroupAffinity) XXX_Merge(src proto.Message) { xxx_messageInfo_WindowsCpuGroupAffinity.Merge(m, src) } func (m *WindowsCpuGroupAffinity) XXX_Size() int { return m.Size() } func (m *WindowsCpuGroupAffinity) XXX_DiscardUnknown() { xxx_messageInfo_WindowsCpuGroupAffinity.DiscardUnknown(m) } var xxx_messageInfo_WindowsCpuGroupAffinity proto.InternalMessageInfo func (m *WindowsCpuGroupAffinity) GetCpuMask() uint64 { if m != nil { return m.CpuMask } return 0 } func (m *WindowsCpuGroupAffinity) GetCpuGroup() uint32 { if m != nil { return m.CpuGroup } return 0 } // ContainerMetadata holds all necessary information for building the container // name. The container runtime is encouraged to expose the metadata in its user // interface for better user experience. E.g., runtime can construct a unique // container name based on the metadata. Note that (name, attempt) is unique // within a sandbox for the entire lifetime of the sandbox. type ContainerMetadata struct { // Name of the container. Same as the container name in the PodSpec. Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` // Attempt number of creating the container. Default: 0. Attempt uint32 `protobuf:"varint,2,opt,name=attempt,proto3" json:"attempt,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ContainerMetadata) Reset() { *m = ContainerMetadata{} } func (*ContainerMetadata) ProtoMessage() {} func (*ContainerMetadata) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{63} } func (m *ContainerMetadata) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ContainerMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ContainerMetadata.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 *ContainerMetadata) XXX_Merge(src proto.Message) { xxx_messageInfo_ContainerMetadata.Merge(m, src) } func (m *ContainerMetadata) XXX_Size() int { return m.Size() } func (m *ContainerMetadata) XXX_DiscardUnknown() { xxx_messageInfo_ContainerMetadata.DiscardUnknown(m) } var xxx_messageInfo_ContainerMetadata proto.InternalMessageInfo func (m *ContainerMetadata) GetName() string { if m != nil { return m.Name } return "" } func (m *ContainerMetadata) GetAttempt() uint32 { if m != nil { return m.Attempt } return 0 } // Device specifies a host device to mount into a container. type Device struct { // Path of the device within the container. ContainerPath string `protobuf:"bytes,1,opt,name=container_path,json=containerPath,proto3" json:"container_path,omitempty"` // Path of the device on the host. HostPath string `protobuf:"bytes,2,opt,name=host_path,json=hostPath,proto3" json:"host_path,omitempty"` // Cgroups permissions of the device, candidates are one or more of // * r - allows container to read from the specified device. // * w - allows container to write to the specified device. // * m - allows container to create device files that do not yet exist. Permissions string `protobuf:"bytes,3,opt,name=permissions,proto3" json:"permissions,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Device) Reset() { *m = Device{} } func (*Device) ProtoMessage() {} func (*Device) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{64} } func (m *Device) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Device) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Device.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 *Device) XXX_Merge(src proto.Message) { xxx_messageInfo_Device.Merge(m, src) } func (m *Device) XXX_Size() int { return m.Size() } func (m *Device) XXX_DiscardUnknown() { xxx_messageInfo_Device.DiscardUnknown(m) } var xxx_messageInfo_Device proto.InternalMessageInfo func (m *Device) GetContainerPath() string { if m != nil { return m.ContainerPath } return "" } func (m *Device) GetHostPath() string { if m != nil { return m.HostPath } return "" } func (m *Device) GetPermissions() string { if m != nil { return m.Permissions } return "" } // CDIDevice specifies a CDI device information. type CDIDevice struct { // Fully qualified CDI device name // for example: vendor.com/gpu=gpudevice1 // see more details in the CDI specification: // https://github.com/container-orchestrated-devices/container-device-interface/blob/main/SPEC.md Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CDIDevice) Reset() { *m = CDIDevice{} } func (*CDIDevice) ProtoMessage() {} func (*CDIDevice) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{65} } func (m *CDIDevice) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CDIDevice) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CDIDevice.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 *CDIDevice) XXX_Merge(src proto.Message) { xxx_messageInfo_CDIDevice.Merge(m, src) } func (m *CDIDevice) XXX_Size() int { return m.Size() } func (m *CDIDevice) XXX_DiscardUnknown() { xxx_messageInfo_CDIDevice.DiscardUnknown(m) } var xxx_messageInfo_CDIDevice proto.InternalMessageInfo func (m *CDIDevice) GetName() string { if m != nil { return m.Name } return "" } // ContainerConfig holds all the required and optional fields for creating a // container. type ContainerConfig struct { // Metadata of the container. This information will uniquely identify the // container, and the runtime should leverage this to ensure correct // operation. The runtime may also use this information to improve UX, such // as by constructing a readable name. Metadata *ContainerMetadata `protobuf:"bytes,1,opt,name=metadata,proto3" json:"metadata,omitempty"` // Image to use. Image *ImageSpec `protobuf:"bytes,2,opt,name=image,proto3" json:"image,omitempty"` // Command to execute (i.e., entrypoint for docker) Command []string `protobuf:"bytes,3,rep,name=command,proto3" json:"command,omitempty"` // Args for the Command (i.e., command for docker) Args []string `protobuf:"bytes,4,rep,name=args,proto3" json:"args,omitempty"` // Current working directory of the command. WorkingDir string `protobuf:"bytes,5,opt,name=working_dir,json=workingDir,proto3" json:"working_dir,omitempty"` // List of environment variable to set in the container. Envs []*KeyValue `protobuf:"bytes,6,rep,name=envs,proto3" json:"envs,omitempty"` // Mounts for the container. Mounts []*Mount `protobuf:"bytes,7,rep,name=mounts,proto3" json:"mounts,omitempty"` // Devices for the container. Devices []*Device `protobuf:"bytes,8,rep,name=devices,proto3" json:"devices,omitempty"` // Key-value pairs that may be used to scope and select individual resources. // Label keys are of the form: // // label-key ::= prefixed-name | name // prefixed-name ::= prefix '/' name // prefix ::= DNS_SUBDOMAIN // name ::= DNS_LABEL Labels map[string]string `protobuf:"bytes,9,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // Unstructured key-value map that may be used by the kubelet to store and // retrieve arbitrary metadata. // // Annotations MUST NOT be altered by the runtime; the annotations stored // here MUST be returned in the ContainerStatus associated with the container // this ContainerConfig creates. // // In general, in order to preserve a well-defined interface between the // kubelet and the container runtime, annotations SHOULD NOT influence // runtime behaviour. Annotations map[string]string `protobuf:"bytes,10,rep,name=annotations,proto3" json:"annotations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // Path relative to PodSandboxConfig.LogDirectory for container to store // the log (STDOUT and STDERR) on the host. // E.g., // // PodSandboxConfig.LogDirectory = `/var/log/pods/__/` // ContainerConfig.LogPath = `containerName/Instance#.log` LogPath string `protobuf:"bytes,11,opt,name=log_path,json=logPath,proto3" json:"log_path,omitempty"` // Variables for interactive containers, these have very specialized // use-cases (e.g. debugging). Stdin bool `protobuf:"varint,12,opt,name=stdin,proto3" json:"stdin,omitempty"` StdinOnce bool `protobuf:"varint,13,opt,name=stdin_once,json=stdinOnce,proto3" json:"stdin_once,omitempty"` Tty bool `protobuf:"varint,14,opt,name=tty,proto3" json:"tty,omitempty"` // Configuration specific to Linux containers. Linux *LinuxContainerConfig `protobuf:"bytes,15,opt,name=linux,proto3" json:"linux,omitempty"` // Configuration specific to Windows containers. Windows *WindowsContainerConfig `protobuf:"bytes,16,opt,name=windows,proto3" json:"windows,omitempty"` // CDI devices for the container. CDIDevices []*CDIDevice `protobuf:"bytes,17,rep,name=CDI_devices,json=CDIDevices,proto3" json:"CDI_devices,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ContainerConfig) Reset() { *m = ContainerConfig{} } func (*ContainerConfig) ProtoMessage() {} func (*ContainerConfig) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{66} } func (m *ContainerConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ContainerConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ContainerConfig.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 *ContainerConfig) XXX_Merge(src proto.Message) { xxx_messageInfo_ContainerConfig.Merge(m, src) } func (m *ContainerConfig) XXX_Size() int { return m.Size() } func (m *ContainerConfig) XXX_DiscardUnknown() { xxx_messageInfo_ContainerConfig.DiscardUnknown(m) } var xxx_messageInfo_ContainerConfig proto.InternalMessageInfo func (m *ContainerConfig) GetMetadata() *ContainerMetadata { if m != nil { return m.Metadata } return nil } func (m *ContainerConfig) GetImage() *ImageSpec { if m != nil { return m.Image } return nil } func (m *ContainerConfig) GetCommand() []string { if m != nil { return m.Command } return nil } func (m *ContainerConfig) GetArgs() []string { if m != nil { return m.Args } return nil } func (m *ContainerConfig) GetWorkingDir() string { if m != nil { return m.WorkingDir } return "" } func (m *ContainerConfig) GetEnvs() []*KeyValue { if m != nil { return m.Envs } return nil } func (m *ContainerConfig) GetMounts() []*Mount { if m != nil { return m.Mounts } return nil } func (m *ContainerConfig) GetDevices() []*Device { if m != nil { return m.Devices } return nil } func (m *ContainerConfig) GetLabels() map[string]string { if m != nil { return m.Labels } return nil } func (m *ContainerConfig) GetAnnotations() map[string]string { if m != nil { return m.Annotations } return nil } func (m *ContainerConfig) GetLogPath() string { if m != nil { return m.LogPath } return "" } func (m *ContainerConfig) GetStdin() bool { if m != nil { return m.Stdin } return false } func (m *ContainerConfig) GetStdinOnce() bool { if m != nil { return m.StdinOnce } return false } func (m *ContainerConfig) GetTty() bool { if m != nil { return m.Tty } return false } func (m *ContainerConfig) GetLinux() *LinuxContainerConfig { if m != nil { return m.Linux } return nil } func (m *ContainerConfig) GetWindows() *WindowsContainerConfig { if m != nil { return m.Windows } return nil } func (m *ContainerConfig) GetCDIDevices() []*CDIDevice { if m != nil { return m.CDIDevices } return nil } type CreateContainerRequest struct { // ID of the PodSandbox in which the container should be created. PodSandboxId string `protobuf:"bytes,1,opt,name=pod_sandbox_id,json=podSandboxId,proto3" json:"pod_sandbox_id,omitempty"` // Config of the container. Config *ContainerConfig `protobuf:"bytes,2,opt,name=config,proto3" json:"config,omitempty"` // Config of the PodSandbox. This is the same config that was passed // to RunPodSandboxRequest to create the PodSandbox. It is passed again // here just for easy reference. The PodSandboxConfig is immutable and // remains the same throughout the lifetime of the pod. SandboxConfig *PodSandboxConfig `protobuf:"bytes,3,opt,name=sandbox_config,json=sandboxConfig,proto3" json:"sandbox_config,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CreateContainerRequest) Reset() { *m = CreateContainerRequest{} } func (*CreateContainerRequest) ProtoMessage() {} func (*CreateContainerRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{67} } func (m *CreateContainerRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CreateContainerRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CreateContainerRequest.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 *CreateContainerRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_CreateContainerRequest.Merge(m, src) } func (m *CreateContainerRequest) XXX_Size() int { return m.Size() } func (m *CreateContainerRequest) XXX_DiscardUnknown() { xxx_messageInfo_CreateContainerRequest.DiscardUnknown(m) } var xxx_messageInfo_CreateContainerRequest proto.InternalMessageInfo func (m *CreateContainerRequest) GetPodSandboxId() string { if m != nil { return m.PodSandboxId } return "" } func (m *CreateContainerRequest) GetConfig() *ContainerConfig { if m != nil { return m.Config } return nil } func (m *CreateContainerRequest) GetSandboxConfig() *PodSandboxConfig { if m != nil { return m.SandboxConfig } return nil } type CreateContainerResponse struct { // ID of the created container. ContainerId string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CreateContainerResponse) Reset() { *m = CreateContainerResponse{} } func (*CreateContainerResponse) ProtoMessage() {} func (*CreateContainerResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{68} } func (m *CreateContainerResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CreateContainerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CreateContainerResponse.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 *CreateContainerResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_CreateContainerResponse.Merge(m, src) } func (m *CreateContainerResponse) XXX_Size() int { return m.Size() } func (m *CreateContainerResponse) XXX_DiscardUnknown() { xxx_messageInfo_CreateContainerResponse.DiscardUnknown(m) } var xxx_messageInfo_CreateContainerResponse proto.InternalMessageInfo func (m *CreateContainerResponse) GetContainerId() string { if m != nil { return m.ContainerId } return "" } type StartContainerRequest struct { // ID of the container to start. ContainerId string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StartContainerRequest) Reset() { *m = StartContainerRequest{} } func (*StartContainerRequest) ProtoMessage() {} func (*StartContainerRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{69} } func (m *StartContainerRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *StartContainerRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_StartContainerRequest.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 *StartContainerRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_StartContainerRequest.Merge(m, src) } func (m *StartContainerRequest) XXX_Size() int { return m.Size() } func (m *StartContainerRequest) XXX_DiscardUnknown() { xxx_messageInfo_StartContainerRequest.DiscardUnknown(m) } var xxx_messageInfo_StartContainerRequest proto.InternalMessageInfo func (m *StartContainerRequest) GetContainerId() string { if m != nil { return m.ContainerId } return "" } type StartContainerResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StartContainerResponse) Reset() { *m = StartContainerResponse{} } func (*StartContainerResponse) ProtoMessage() {} func (*StartContainerResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{70} } func (m *StartContainerResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *StartContainerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_StartContainerResponse.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 *StartContainerResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_StartContainerResponse.Merge(m, src) } func (m *StartContainerResponse) XXX_Size() int { return m.Size() } func (m *StartContainerResponse) XXX_DiscardUnknown() { xxx_messageInfo_StartContainerResponse.DiscardUnknown(m) } var xxx_messageInfo_StartContainerResponse proto.InternalMessageInfo type StopContainerRequest struct { // ID of the container to stop. ContainerId string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` // Timeout in seconds to wait for the container to stop before forcibly // terminating it. Default: 0 (forcibly terminate the container immediately) Timeout int64 `protobuf:"varint,2,opt,name=timeout,proto3" json:"timeout,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StopContainerRequest) Reset() { *m = StopContainerRequest{} } func (*StopContainerRequest) ProtoMessage() {} func (*StopContainerRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{71} } func (m *StopContainerRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *StopContainerRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_StopContainerRequest.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 *StopContainerRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_StopContainerRequest.Merge(m, src) } func (m *StopContainerRequest) XXX_Size() int { return m.Size() } func (m *StopContainerRequest) XXX_DiscardUnknown() { xxx_messageInfo_StopContainerRequest.DiscardUnknown(m) } var xxx_messageInfo_StopContainerRequest proto.InternalMessageInfo func (m *StopContainerRequest) GetContainerId() string { if m != nil { return m.ContainerId } return "" } func (m *StopContainerRequest) GetTimeout() int64 { if m != nil { return m.Timeout } return 0 } type StopContainerResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StopContainerResponse) Reset() { *m = StopContainerResponse{} } func (*StopContainerResponse) ProtoMessage() {} func (*StopContainerResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{72} } func (m *StopContainerResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *StopContainerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_StopContainerResponse.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 *StopContainerResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_StopContainerResponse.Merge(m, src) } func (m *StopContainerResponse) XXX_Size() int { return m.Size() } func (m *StopContainerResponse) XXX_DiscardUnknown() { xxx_messageInfo_StopContainerResponse.DiscardUnknown(m) } var xxx_messageInfo_StopContainerResponse proto.InternalMessageInfo type RemoveContainerRequest struct { // ID of the container to remove. ContainerId string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RemoveContainerRequest) Reset() { *m = RemoveContainerRequest{} } func (*RemoveContainerRequest) ProtoMessage() {} func (*RemoveContainerRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{73} } func (m *RemoveContainerRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RemoveContainerRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RemoveContainerRequest.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 *RemoveContainerRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RemoveContainerRequest.Merge(m, src) } func (m *RemoveContainerRequest) XXX_Size() int { return m.Size() } func (m *RemoveContainerRequest) XXX_DiscardUnknown() { xxx_messageInfo_RemoveContainerRequest.DiscardUnknown(m) } var xxx_messageInfo_RemoveContainerRequest proto.InternalMessageInfo func (m *RemoveContainerRequest) GetContainerId() string { if m != nil { return m.ContainerId } return "" } type RemoveContainerResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RemoveContainerResponse) Reset() { *m = RemoveContainerResponse{} } func (*RemoveContainerResponse) ProtoMessage() {} func (*RemoveContainerResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{74} } func (m *RemoveContainerResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RemoveContainerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RemoveContainerResponse.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 *RemoveContainerResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RemoveContainerResponse.Merge(m, src) } func (m *RemoveContainerResponse) XXX_Size() int { return m.Size() } func (m *RemoveContainerResponse) XXX_DiscardUnknown() { xxx_messageInfo_RemoveContainerResponse.DiscardUnknown(m) } var xxx_messageInfo_RemoveContainerResponse proto.InternalMessageInfo // ContainerStateValue is the wrapper of ContainerState. type ContainerStateValue struct { // State of the container. State ContainerState `protobuf:"varint,1,opt,name=state,proto3,enum=runtime.v1.ContainerState" json:"state,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ContainerStateValue) Reset() { *m = ContainerStateValue{} } func (*ContainerStateValue) ProtoMessage() {} func (*ContainerStateValue) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{75} } func (m *ContainerStateValue) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ContainerStateValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ContainerStateValue.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 *ContainerStateValue) XXX_Merge(src proto.Message) { xxx_messageInfo_ContainerStateValue.Merge(m, src) } func (m *ContainerStateValue) XXX_Size() int { return m.Size() } func (m *ContainerStateValue) XXX_DiscardUnknown() { xxx_messageInfo_ContainerStateValue.DiscardUnknown(m) } var xxx_messageInfo_ContainerStateValue proto.InternalMessageInfo func (m *ContainerStateValue) GetState() ContainerState { if m != nil { return m.State } return ContainerState_CONTAINER_CREATED } // ContainerFilter is used to filter containers. // All those fields are combined with 'AND' type ContainerFilter struct { // ID of the container. Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` // State of the container. State *ContainerStateValue `protobuf:"bytes,2,opt,name=state,proto3" json:"state,omitempty"` // ID of the PodSandbox. PodSandboxId string `protobuf:"bytes,3,opt,name=pod_sandbox_id,json=podSandboxId,proto3" json:"pod_sandbox_id,omitempty"` // LabelSelector to select matches. // Only api.MatchLabels is supported for now and the requirements // are ANDed. MatchExpressions is not supported yet. LabelSelector map[string]string `protobuf:"bytes,4,rep,name=label_selector,json=labelSelector,proto3" json:"label_selector,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:"-"` } func (m *ContainerFilter) Reset() { *m = ContainerFilter{} } func (*ContainerFilter) ProtoMessage() {} func (*ContainerFilter) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{76} } func (m *ContainerFilter) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ContainerFilter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ContainerFilter.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 *ContainerFilter) XXX_Merge(src proto.Message) { xxx_messageInfo_ContainerFilter.Merge(m, src) } func (m *ContainerFilter) XXX_Size() int { return m.Size() } func (m *ContainerFilter) XXX_DiscardUnknown() { xxx_messageInfo_ContainerFilter.DiscardUnknown(m) } var xxx_messageInfo_ContainerFilter proto.InternalMessageInfo func (m *ContainerFilter) GetId() string { if m != nil { return m.Id } return "" } func (m *ContainerFilter) GetState() *ContainerStateValue { if m != nil { return m.State } return nil } func (m *ContainerFilter) GetPodSandboxId() string { if m != nil { return m.PodSandboxId } return "" } func (m *ContainerFilter) GetLabelSelector() map[string]string { if m != nil { return m.LabelSelector } return nil } type ListContainersRequest struct { Filter *ContainerFilter `protobuf:"bytes,1,opt,name=filter,proto3" json:"filter,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListContainersRequest) Reset() { *m = ListContainersRequest{} } func (*ListContainersRequest) ProtoMessage() {} func (*ListContainersRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{77} } func (m *ListContainersRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListContainersRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListContainersRequest.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 *ListContainersRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ListContainersRequest.Merge(m, src) } func (m *ListContainersRequest) XXX_Size() int { return m.Size() } func (m *ListContainersRequest) XXX_DiscardUnknown() { xxx_messageInfo_ListContainersRequest.DiscardUnknown(m) } var xxx_messageInfo_ListContainersRequest proto.InternalMessageInfo func (m *ListContainersRequest) GetFilter() *ContainerFilter { if m != nil { return m.Filter } return nil } // Container provides the runtime information for a container, such as ID, hash, // state of the container. type Container struct { // ID of the container, used by the container runtime to identify // a container. Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` // ID of the sandbox to which this container belongs. PodSandboxId string `protobuf:"bytes,2,opt,name=pod_sandbox_id,json=podSandboxId,proto3" json:"pod_sandbox_id,omitempty"` // Metadata of the container. 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"` // 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"` // Creation time of the container in nanoseconds. CreatedAt int64 `protobuf:"varint,7,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` // Key-value pairs that may be used to scope and select individual resources. Labels map[string]string `protobuf:"bytes,8,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // Unstructured key-value map holding arbitrary metadata. // 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"` // 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{78} } func (m *Container) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Container) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Container.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 *Container) XXX_Merge(src proto.Message) { xxx_messageInfo_Container.Merge(m, src) } func (m *Container) XXX_Size() int { return m.Size() } func (m *Container) XXX_DiscardUnknown() { xxx_messageInfo_Container.DiscardUnknown(m) } var xxx_messageInfo_Container proto.InternalMessageInfo func (m *Container) GetId() string { if m != nil { return m.Id } return "" } func (m *Container) GetPodSandboxId() string { if m != nil { return m.PodSandboxId } return "" } func (m *Container) GetMetadata() *ContainerMetadata { if m != nil { return m.Metadata } return nil } func (m *Container) GetImage() *ImageSpec { if m != nil { return m.Image } return nil } func (m *Container) GetImageRef() string { if m != nil { return m.ImageRef } return "" } func (m *Container) GetState() ContainerState { if m != nil { return m.State } return ContainerState_CONTAINER_CREATED } func (m *Container) GetCreatedAt() int64 { if m != nil { return m.CreatedAt } return 0 } func (m *Container) GetLabels() map[string]string { if m != nil { return m.Labels } return nil } func (m *Container) GetAnnotations() map[string]string { if m != nil { return m.Annotations } 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"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListContainersResponse) Reset() { *m = ListContainersResponse{} } func (*ListContainersResponse) ProtoMessage() {} func (*ListContainersResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{79} } func (m *ListContainersResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListContainersResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListContainersResponse.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 *ListContainersResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ListContainersResponse.Merge(m, src) } func (m *ListContainersResponse) XXX_Size() int { return m.Size() } func (m *ListContainersResponse) XXX_DiscardUnknown() { xxx_messageInfo_ListContainersResponse.DiscardUnknown(m) } var xxx_messageInfo_ListContainersResponse proto.InternalMessageInfo func (m *ListContainersResponse) GetContainers() []*Container { if m != nil { return m.Containers } return nil } type ContainerStatusRequest struct { // ID of the container for which to retrieve status. ContainerId string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` // Verbose indicates whether to return extra information about the container. Verbose bool `protobuf:"varint,2,opt,name=verbose,proto3" json:"verbose,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ContainerStatusRequest) Reset() { *m = ContainerStatusRequest{} } func (*ContainerStatusRequest) ProtoMessage() {} func (*ContainerStatusRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{80} } func (m *ContainerStatusRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ContainerStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ContainerStatusRequest.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 *ContainerStatusRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ContainerStatusRequest.Merge(m, src) } func (m *ContainerStatusRequest) XXX_Size() int { return m.Size() } func (m *ContainerStatusRequest) XXX_DiscardUnknown() { xxx_messageInfo_ContainerStatusRequest.DiscardUnknown(m) } var xxx_messageInfo_ContainerStatusRequest proto.InternalMessageInfo func (m *ContainerStatusRequest) GetContainerId() string { if m != nil { return m.ContainerId } return "" } func (m *ContainerStatusRequest) GetVerbose() bool { if m != nil { return m.Verbose } return false } // ContainerStatus represents the status of a container. type ContainerStatus struct { // ID of the container. Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` // Metadata of the container. Metadata *ContainerMetadata `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"` // Status of the container. State ContainerState `protobuf:"varint,3,opt,name=state,proto3,enum=runtime.v1.ContainerState" json:"state,omitempty"` // Creation time of the container in nanoseconds. CreatedAt int64 `protobuf:"varint,4,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` // Start time of the container in nanoseconds. Default: 0 (not specified). StartedAt int64 `protobuf:"varint,5,opt,name=started_at,json=startedAt,proto3" json:"started_at,omitempty"` // Finish time of the container in nanoseconds. Default: 0 (not specified). FinishedAt int64 `protobuf:"varint,6,opt,name=finished_at,json=finishedAt,proto3" json:"finished_at,omitempty"` // Exit code of the container. Only required when finished_at != 0. Default: 0. 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"` // 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. Reason string `protobuf:"bytes,10,opt,name=reason,proto3" json:"reason,omitempty"` // Human-readable message indicating details about why container is in its // current state. Message string `protobuf:"bytes,11,opt,name=message,proto3" json:"message,omitempty"` // Key-value pairs that may be used to scope and select individual resources. Labels map[string]string `protobuf:"bytes,12,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // Unstructured key-value map holding arbitrary metadata. // 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 the Container this status represents. Annotations map[string]string `protobuf:"bytes,13,rep,name=annotations,proto3" json:"annotations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // Mounts for the container. Mounts []*Mount `protobuf:"bytes,14,rep,name=mounts,proto3" json:"mounts,omitempty"` // 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"` // 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{81} } func (m *ContainerStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ContainerStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ContainerStatus.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 *ContainerStatus) XXX_Merge(src proto.Message) { xxx_messageInfo_ContainerStatus.Merge(m, src) } func (m *ContainerStatus) XXX_Size() int { return m.Size() } func (m *ContainerStatus) XXX_DiscardUnknown() { xxx_messageInfo_ContainerStatus.DiscardUnknown(m) } var xxx_messageInfo_ContainerStatus proto.InternalMessageInfo func (m *ContainerStatus) GetId() string { if m != nil { return m.Id } return "" } func (m *ContainerStatus) GetMetadata() *ContainerMetadata { if m != nil { return m.Metadata } return nil } func (m *ContainerStatus) GetState() ContainerState { if m != nil { return m.State } return ContainerState_CONTAINER_CREATED } func (m *ContainerStatus) GetCreatedAt() int64 { if m != nil { return m.CreatedAt } return 0 } func (m *ContainerStatus) GetStartedAt() int64 { if m != nil { return m.StartedAt } return 0 } func (m *ContainerStatus) GetFinishedAt() int64 { if m != nil { return m.FinishedAt } return 0 } func (m *ContainerStatus) GetExitCode() int32 { if m != nil { return m.ExitCode } return 0 } func (m *ContainerStatus) GetImage() *ImageSpec { if m != nil { return m.Image } return nil } func (m *ContainerStatus) GetImageRef() string { if m != nil { return m.ImageRef } return "" } func (m *ContainerStatus) GetReason() string { if m != nil { return m.Reason } return "" } func (m *ContainerStatus) GetMessage() string { if m != nil { return m.Message } return "" } func (m *ContainerStatus) GetLabels() map[string]string { if m != nil { return m.Labels } return nil } func (m *ContainerStatus) GetAnnotations() map[string]string { if m != nil { return m.Annotations } return nil } func (m *ContainerStatus) GetMounts() []*Mount { if m != nil { return m.Mounts } return nil } func (m *ContainerStatus) GetLogPath() string { if m != nil { return m.LogPath } return "" } func (m *ContainerStatus) GetResources() *ContainerResources { if m != nil { return m.Resources } 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"` // Info is extra information of the Container. The key could be arbitrary string, and // value should be in json format. The information could include anything useful for // debug, e.g. pid for linux container based 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:"-"` } func (m *ContainerStatusResponse) Reset() { *m = ContainerStatusResponse{} } func (*ContainerStatusResponse) ProtoMessage() {} func (*ContainerStatusResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{82} } func (m *ContainerStatusResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ContainerStatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ContainerStatusResponse.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 *ContainerStatusResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ContainerStatusResponse.Merge(m, src) } func (m *ContainerStatusResponse) XXX_Size() int { return m.Size() } func (m *ContainerStatusResponse) XXX_DiscardUnknown() { xxx_messageInfo_ContainerStatusResponse.DiscardUnknown(m) } var xxx_messageInfo_ContainerStatusResponse proto.InternalMessageInfo func (m *ContainerStatusResponse) GetStatus() *ContainerStatus { if m != nil { return m.Status } return nil } func (m *ContainerStatusResponse) GetInfo() map[string]string { if m != nil { return m.Info } return nil } // ContainerResources holds resource limits configuration for a container. type ContainerResources struct { // Resource limits configuration specific to Linux container. Linux *LinuxContainerResources `protobuf:"bytes,1,opt,name=linux,proto3" json:"linux,omitempty"` // Resource limits configuration specific to Windows container. Windows *WindowsContainerResources `protobuf:"bytes,2,opt,name=windows,proto3" json:"windows,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ContainerResources) Reset() { *m = ContainerResources{} } func (*ContainerResources) ProtoMessage() {} func (*ContainerResources) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{83} } func (m *ContainerResources) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ContainerResources) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ContainerResources.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 *ContainerResources) XXX_Merge(src proto.Message) { xxx_messageInfo_ContainerResources.Merge(m, src) } func (m *ContainerResources) XXX_Size() int { return m.Size() } func (m *ContainerResources) XXX_DiscardUnknown() { xxx_messageInfo_ContainerResources.DiscardUnknown(m) } var xxx_messageInfo_ContainerResources proto.InternalMessageInfo func (m *ContainerResources) GetLinux() *LinuxContainerResources { if m != nil { return m.Linux } return nil } func (m *ContainerResources) GetWindows() *WindowsContainerResources { if m != nil { return m.Windows } 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{84} } 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"` // Resource configuration specific to Linux containers. Linux *LinuxContainerResources `protobuf:"bytes,2,opt,name=linux,proto3" json:"linux,omitempty"` // Resource configuration specific to Windows containers. Windows *WindowsContainerResources `protobuf:"bytes,3,opt,name=windows,proto3" json:"windows,omitempty"` // Unstructured key-value map holding arbitrary additional information for // container resources updating. This can be used for specifying experimental // resources to update or other options to use when updating the container. Annotations map[string]string `protobuf:"bytes,4,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:"-"` } func (m *UpdateContainerResourcesRequest) Reset() { *m = UpdateContainerResourcesRequest{} } func (*UpdateContainerResourcesRequest) ProtoMessage() {} func (*UpdateContainerResourcesRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{85} } func (m *UpdateContainerResourcesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *UpdateContainerResourcesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_UpdateContainerResourcesRequest.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 *UpdateContainerResourcesRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_UpdateContainerResourcesRequest.Merge(m, src) } func (m *UpdateContainerResourcesRequest) XXX_Size() int { return m.Size() } func (m *UpdateContainerResourcesRequest) XXX_DiscardUnknown() { xxx_messageInfo_UpdateContainerResourcesRequest.DiscardUnknown(m) } var xxx_messageInfo_UpdateContainerResourcesRequest proto.InternalMessageInfo func (m *UpdateContainerResourcesRequest) GetContainerId() string { if m != nil { return m.ContainerId } return "" } func (m *UpdateContainerResourcesRequest) GetLinux() *LinuxContainerResources { if m != nil { return m.Linux } return nil } func (m *UpdateContainerResourcesRequest) GetWindows() *WindowsContainerResources { if m != nil { return m.Windows } return nil } func (m *UpdateContainerResourcesRequest) GetAnnotations() map[string]string { if m != nil { return m.Annotations } return nil } type UpdateContainerResourcesResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *UpdateContainerResourcesResponse) Reset() { *m = UpdateContainerResourcesResponse{} } func (*UpdateContainerResourcesResponse) ProtoMessage() {} func (*UpdateContainerResourcesResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{86} } func (m *UpdateContainerResourcesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *UpdateContainerResourcesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_UpdateContainerResourcesResponse.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 *UpdateContainerResourcesResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_UpdateContainerResourcesResponse.Merge(m, src) } func (m *UpdateContainerResourcesResponse) XXX_Size() int { return m.Size() } func (m *UpdateContainerResourcesResponse) XXX_DiscardUnknown() { xxx_messageInfo_UpdateContainerResourcesResponse.DiscardUnknown(m) } var xxx_messageInfo_UpdateContainerResourcesResponse proto.InternalMessageInfo type ExecSyncRequest struct { // ID of the container. ContainerId string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` // Command to execute. Cmd []string `protobuf:"bytes,2,rep,name=cmd,proto3" json:"cmd,omitempty"` // Timeout in seconds to stop the command. Default: 0 (run forever). Timeout int64 `protobuf:"varint,3,opt,name=timeout,proto3" json:"timeout,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ExecSyncRequest) Reset() { *m = ExecSyncRequest{} } func (*ExecSyncRequest) ProtoMessage() {} func (*ExecSyncRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{87} } func (m *ExecSyncRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ExecSyncRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ExecSyncRequest.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 *ExecSyncRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ExecSyncRequest.Merge(m, src) } func (m *ExecSyncRequest) XXX_Size() int { return m.Size() } func (m *ExecSyncRequest) XXX_DiscardUnknown() { xxx_messageInfo_ExecSyncRequest.DiscardUnknown(m) } var xxx_messageInfo_ExecSyncRequest proto.InternalMessageInfo func (m *ExecSyncRequest) GetContainerId() string { if m != nil { return m.ContainerId } return "" } func (m *ExecSyncRequest) GetCmd() []string { if m != nil { return m.Cmd } return nil } func (m *ExecSyncRequest) GetTimeout() int64 { if m != nil { return m.Timeout } return 0 } type ExecSyncResponse struct { // Captured command stdout output. // The runtime should cap the output of this response to 16MB. // If the stdout of the command produces more than 16MB, the remaining output // should be discarded, and the command should proceed with no error. // See CVE-2022-1708 and CVE-2022-31030 for more information. Stdout []byte `protobuf:"bytes,1,opt,name=stdout,proto3" json:"stdout,omitempty"` // Captured command stderr output. // The runtime should cap the output of this response to 16MB. // If the stderr of the command produces more than 16MB, the remaining output // should be discarded, and the command should proceed with no error. // See CVE-2022-1708 and CVE-2022-31030 for more information. Stderr []byte `protobuf:"bytes,2,opt,name=stderr,proto3" json:"stderr,omitempty"` // Exit code the command finished with. Default: 0 (success). ExitCode int32 `protobuf:"varint,3,opt,name=exit_code,json=exitCode,proto3" json:"exit_code,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ExecSyncResponse) Reset() { *m = ExecSyncResponse{} } func (*ExecSyncResponse) ProtoMessage() {} func (*ExecSyncResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{88} } func (m *ExecSyncResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ExecSyncResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ExecSyncResponse.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 *ExecSyncResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ExecSyncResponse.Merge(m, src) } func (m *ExecSyncResponse) XXX_Size() int { return m.Size() } func (m *ExecSyncResponse) XXX_DiscardUnknown() { xxx_messageInfo_ExecSyncResponse.DiscardUnknown(m) } var xxx_messageInfo_ExecSyncResponse proto.InternalMessageInfo func (m *ExecSyncResponse) GetStdout() []byte { if m != nil { return m.Stdout } return nil } func (m *ExecSyncResponse) GetStderr() []byte { if m != nil { return m.Stderr } return nil } func (m *ExecSyncResponse) GetExitCode() int32 { if m != nil { return m.ExitCode } return 0 } type ExecRequest struct { // ID of the container in which to execute the command. ContainerId string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` // Command to execute. Cmd []string `protobuf:"bytes,2,rep,name=cmd,proto3" json:"cmd,omitempty"` // Whether to exec the command in a TTY. Tty bool `protobuf:"varint,3,opt,name=tty,proto3" json:"tty,omitempty"` // Whether to stream stdin. // One of `stdin`, `stdout`, and `stderr` MUST be true. Stdin bool `protobuf:"varint,4,opt,name=stdin,proto3" json:"stdin,omitempty"` // Whether to stream stdout. // One of `stdin`, `stdout`, and `stderr` MUST be true. Stdout bool `protobuf:"varint,5,opt,name=stdout,proto3" json:"stdout,omitempty"` // Whether to stream stderr. // One of `stdin`, `stdout`, and `stderr` MUST be true. // If `tty` is true, `stderr` MUST be false. Multiplexing is not supported // in this case. The output of stdout and stderr will be combined to a // single stream. Stderr bool `protobuf:"varint,6,opt,name=stderr,proto3" json:"stderr,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ExecRequest) Reset() { *m = ExecRequest{} } func (*ExecRequest) ProtoMessage() {} func (*ExecRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{89} } func (m *ExecRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ExecRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ExecRequest.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 *ExecRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ExecRequest.Merge(m, src) } func (m *ExecRequest) XXX_Size() int { return m.Size() } func (m *ExecRequest) XXX_DiscardUnknown() { xxx_messageInfo_ExecRequest.DiscardUnknown(m) } var xxx_messageInfo_ExecRequest proto.InternalMessageInfo func (m *ExecRequest) GetContainerId() string { if m != nil { return m.ContainerId } return "" } func (m *ExecRequest) GetCmd() []string { if m != nil { return m.Cmd } return nil } func (m *ExecRequest) GetTty() bool { if m != nil { return m.Tty } return false } func (m *ExecRequest) GetStdin() bool { if m != nil { return m.Stdin } return false } func (m *ExecRequest) GetStdout() bool { if m != nil { return m.Stdout } return false } func (m *ExecRequest) GetStderr() bool { if m != nil { return m.Stderr } return false } type ExecResponse struct { // Fully qualified URL of the exec streaming server. Url string `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ExecResponse) Reset() { *m = ExecResponse{} } func (*ExecResponse) ProtoMessage() {} func (*ExecResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{90} } func (m *ExecResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ExecResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ExecResponse.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 *ExecResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ExecResponse.Merge(m, src) } func (m *ExecResponse) XXX_Size() int { return m.Size() } func (m *ExecResponse) XXX_DiscardUnknown() { xxx_messageInfo_ExecResponse.DiscardUnknown(m) } var xxx_messageInfo_ExecResponse proto.InternalMessageInfo func (m *ExecResponse) GetUrl() string { if m != nil { return m.Url } return "" } type AttachRequest struct { // ID of the container to which to attach. ContainerId string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` // Whether to stream stdin. // One of `stdin`, `stdout`, and `stderr` MUST be true. Stdin bool `protobuf:"varint,2,opt,name=stdin,proto3" json:"stdin,omitempty"` // Whether the process being attached is running in a TTY. // This must match the TTY setting in the ContainerConfig. Tty bool `protobuf:"varint,3,opt,name=tty,proto3" json:"tty,omitempty"` // Whether to stream stdout. // One of `stdin`, `stdout`, and `stderr` MUST be true. Stdout bool `protobuf:"varint,4,opt,name=stdout,proto3" json:"stdout,omitempty"` // Whether to stream stderr. // One of `stdin`, `stdout`, and `stderr` MUST be true. // If `tty` is true, `stderr` MUST be false. Multiplexing is not supported // in this case. The output of stdout and stderr will be combined to a // single stream. Stderr bool `protobuf:"varint,5,opt,name=stderr,proto3" json:"stderr,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *AttachRequest) Reset() { *m = AttachRequest{} } func (*AttachRequest) ProtoMessage() {} func (*AttachRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{91} } func (m *AttachRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *AttachRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_AttachRequest.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 *AttachRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_AttachRequest.Merge(m, src) } func (m *AttachRequest) XXX_Size() int { return m.Size() } func (m *AttachRequest) XXX_DiscardUnknown() { xxx_messageInfo_AttachRequest.DiscardUnknown(m) } var xxx_messageInfo_AttachRequest proto.InternalMessageInfo func (m *AttachRequest) GetContainerId() string { if m != nil { return m.ContainerId } return "" } func (m *AttachRequest) GetStdin() bool { if m != nil { return m.Stdin } return false } func (m *AttachRequest) GetTty() bool { if m != nil { return m.Tty } return false } func (m *AttachRequest) GetStdout() bool { if m != nil { return m.Stdout } return false } func (m *AttachRequest) GetStderr() bool { if m != nil { return m.Stderr } return false } type AttachResponse struct { // Fully qualified URL of the attach streaming server. Url string `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *AttachResponse) Reset() { *m = AttachResponse{} } func (*AttachResponse) ProtoMessage() {} func (*AttachResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{92} } func (m *AttachResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *AttachResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_AttachResponse.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 *AttachResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_AttachResponse.Merge(m, src) } func (m *AttachResponse) XXX_Size() int { return m.Size() } func (m *AttachResponse) XXX_DiscardUnknown() { xxx_messageInfo_AttachResponse.DiscardUnknown(m) } var xxx_messageInfo_AttachResponse proto.InternalMessageInfo func (m *AttachResponse) GetUrl() string { if m != nil { return m.Url } return "" } type PortForwardRequest struct { // ID of the container to which to forward the port. PodSandboxId string `protobuf:"bytes,1,opt,name=pod_sandbox_id,json=podSandboxId,proto3" json:"pod_sandbox_id,omitempty"` // Port to forward. Port []int32 `protobuf:"varint,2,rep,packed,name=port,proto3" json:"port,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PortForwardRequest) Reset() { *m = PortForwardRequest{} } func (*PortForwardRequest) ProtoMessage() {} func (*PortForwardRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{93} } func (m *PortForwardRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PortForwardRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PortForwardRequest.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 *PortForwardRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_PortForwardRequest.Merge(m, src) } func (m *PortForwardRequest) XXX_Size() int { return m.Size() } func (m *PortForwardRequest) XXX_DiscardUnknown() { xxx_messageInfo_PortForwardRequest.DiscardUnknown(m) } var xxx_messageInfo_PortForwardRequest proto.InternalMessageInfo func (m *PortForwardRequest) GetPodSandboxId() string { if m != nil { return m.PodSandboxId } return "" } func (m *PortForwardRequest) GetPort() []int32 { if m != nil { return m.Port } return nil } type PortForwardResponse struct { // Fully qualified URL of the port-forward streaming server. Url string `protobuf:"bytes,1,opt,name=url,proto3" json:"url,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PortForwardResponse) Reset() { *m = PortForwardResponse{} } func (*PortForwardResponse) ProtoMessage() {} func (*PortForwardResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{94} } func (m *PortForwardResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PortForwardResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PortForwardResponse.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 *PortForwardResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_PortForwardResponse.Merge(m, src) } func (m *PortForwardResponse) XXX_Size() int { return m.Size() } func (m *PortForwardResponse) XXX_DiscardUnknown() { xxx_messageInfo_PortForwardResponse.DiscardUnknown(m) } var xxx_messageInfo_PortForwardResponse proto.InternalMessageInfo func (m *PortForwardResponse) GetUrl() string { if m != nil { return m.Url } return "" } type ImageFilter struct { // Spec of the image. Image *ImageSpec `protobuf:"bytes,1,opt,name=image,proto3" json:"image,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ImageFilter) Reset() { *m = ImageFilter{} } func (*ImageFilter) ProtoMessage() {} func (*ImageFilter) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{95} } func (m *ImageFilter) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ImageFilter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ImageFilter.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 *ImageFilter) XXX_Merge(src proto.Message) { xxx_messageInfo_ImageFilter.Merge(m, src) } func (m *ImageFilter) XXX_Size() int { return m.Size() } func (m *ImageFilter) XXX_DiscardUnknown() { xxx_messageInfo_ImageFilter.DiscardUnknown(m) } var xxx_messageInfo_ImageFilter proto.InternalMessageInfo func (m *ImageFilter) GetImage() *ImageSpec { if m != nil { return m.Image } return nil } type ListImagesRequest struct { // Filter to list images. Filter *ImageFilter `protobuf:"bytes,1,opt,name=filter,proto3" json:"filter,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListImagesRequest) Reset() { *m = ListImagesRequest{} } func (*ListImagesRequest) ProtoMessage() {} func (*ListImagesRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{96} } func (m *ListImagesRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListImagesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListImagesRequest.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 *ListImagesRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ListImagesRequest.Merge(m, src) } func (m *ListImagesRequest) XXX_Size() int { return m.Size() } func (m *ListImagesRequest) XXX_DiscardUnknown() { xxx_messageInfo_ListImagesRequest.DiscardUnknown(m) } var xxx_messageInfo_ListImagesRequest proto.InternalMessageInfo func (m *ListImagesRequest) GetFilter() *ImageFilter { if m != nil { return m.Filter } return nil } // Basic information about a container image. type Image struct { // ID of the image. Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` // Other names by which this image is known. RepoTags []string `protobuf:"bytes,2,rep,name=repo_tags,json=repoTags,proto3" json:"repo_tags,omitempty"` // Digests by which this image is known. RepoDigests []string `protobuf:"bytes,3,rep,name=repo_digests,json=repoDigests,proto3" json:"repo_digests,omitempty"` // Size of the image in bytes. Must be > 0. Size_ uint64 `protobuf:"varint,4,opt,name=size,proto3" json:"size,omitempty"` // UID that will run the command(s). This is used as a default if no user is // specified when creating the container. UID and the following user name // are mutually exclusive. Uid *Int64Value `protobuf:"bytes,5,opt,name=uid,proto3" json:"uid,omitempty"` // User name that will run the command(s). This is used if UID is not set // and no user is specified when creating container. Username string `protobuf:"bytes,6,opt,name=username,proto3" json:"username,omitempty"` // ImageSpec for image which includes annotations Spec *ImageSpec `protobuf:"bytes,7,opt,name=spec,proto3" json:"spec,omitempty"` // Recommendation on whether this image should be exempt from garbage collection. // It must only be treated as a recommendation -- the client can still request that the image be deleted, // and the runtime must oblige. Pinned bool `protobuf:"varint,8,opt,name=pinned,proto3" json:"pinned,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Image) Reset() { *m = Image{} } func (*Image) ProtoMessage() {} func (*Image) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{97} } func (m *Image) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Image) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Image.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 *Image) XXX_Merge(src proto.Message) { xxx_messageInfo_Image.Merge(m, src) } func (m *Image) XXX_Size() int { return m.Size() } func (m *Image) XXX_DiscardUnknown() { xxx_messageInfo_Image.DiscardUnknown(m) } var xxx_messageInfo_Image proto.InternalMessageInfo func (m *Image) GetId() string { if m != nil { return m.Id } return "" } func (m *Image) GetRepoTags() []string { if m != nil { return m.RepoTags } return nil } func (m *Image) GetRepoDigests() []string { if m != nil { return m.RepoDigests } return nil } func (m *Image) GetSize_() uint64 { if m != nil { return m.Size_ } return 0 } func (m *Image) GetUid() *Int64Value { if m != nil { return m.Uid } return nil } func (m *Image) GetUsername() string { if m != nil { return m.Username } return "" } func (m *Image) GetSpec() *ImageSpec { if m != nil { return m.Spec } return nil } func (m *Image) GetPinned() bool { if m != nil { return m.Pinned } return false } type ListImagesResponse struct { // List of images. Images []*Image `protobuf:"bytes,1,rep,name=images,proto3" json:"images,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListImagesResponse) Reset() { *m = ListImagesResponse{} } func (*ListImagesResponse) ProtoMessage() {} func (*ListImagesResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{98} } func (m *ListImagesResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListImagesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListImagesResponse.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 *ListImagesResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ListImagesResponse.Merge(m, src) } func (m *ListImagesResponse) XXX_Size() int { return m.Size() } func (m *ListImagesResponse) XXX_DiscardUnknown() { xxx_messageInfo_ListImagesResponse.DiscardUnknown(m) } var xxx_messageInfo_ListImagesResponse proto.InternalMessageInfo func (m *ListImagesResponse) GetImages() []*Image { if m != nil { return m.Images } return nil } type ImageStatusRequest struct { // Spec of the image. Image *ImageSpec `protobuf:"bytes,1,opt,name=image,proto3" json:"image,omitempty"` // Verbose indicates whether to return extra information about the image. Verbose bool `protobuf:"varint,2,opt,name=verbose,proto3" json:"verbose,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ImageStatusRequest) Reset() { *m = ImageStatusRequest{} } func (*ImageStatusRequest) ProtoMessage() {} func (*ImageStatusRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{99} } func (m *ImageStatusRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ImageStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ImageStatusRequest.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 *ImageStatusRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ImageStatusRequest.Merge(m, src) } func (m *ImageStatusRequest) XXX_Size() int { return m.Size() } func (m *ImageStatusRequest) XXX_DiscardUnknown() { xxx_messageInfo_ImageStatusRequest.DiscardUnknown(m) } var xxx_messageInfo_ImageStatusRequest proto.InternalMessageInfo func (m *ImageStatusRequest) GetImage() *ImageSpec { if m != nil { return m.Image } return nil } func (m *ImageStatusRequest) GetVerbose() bool { if m != nil { return m.Verbose } return false } type ImageStatusResponse struct { // Status of the image. Image *Image `protobuf:"bytes,1,opt,name=image,proto3" json:"image,omitempty"` // Info is extra information of the Image. The key could be arbitrary string, and // value should be in json format. The information could include anything useful // for debug, e.g. image config for oci image based 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:"-"` } func (m *ImageStatusResponse) Reset() { *m = ImageStatusResponse{} } func (*ImageStatusResponse) ProtoMessage() {} func (*ImageStatusResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{100} } func (m *ImageStatusResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ImageStatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ImageStatusResponse.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 *ImageStatusResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ImageStatusResponse.Merge(m, src) } func (m *ImageStatusResponse) XXX_Size() int { return m.Size() } func (m *ImageStatusResponse) XXX_DiscardUnknown() { xxx_messageInfo_ImageStatusResponse.DiscardUnknown(m) } var xxx_messageInfo_ImageStatusResponse proto.InternalMessageInfo func (m *ImageStatusResponse) GetImage() *Image { if m != nil { return m.Image } return nil } func (m *ImageStatusResponse) GetInfo() map[string]string { if m != nil { return m.Info } return nil } // AuthConfig contains authorization information for connecting to a registry. type AuthConfig struct { Username string `protobuf:"bytes,1,opt,name=username,proto3" json:"username,omitempty"` Password string `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"` Auth string `protobuf:"bytes,3,opt,name=auth,proto3" json:"auth,omitempty"` ServerAddress string `protobuf:"bytes,4,opt,name=server_address,json=serverAddress,proto3" json:"server_address,omitempty"` // IdentityToken is used to authenticate the user and get // an access token for the registry. IdentityToken string `protobuf:"bytes,5,opt,name=identity_token,json=identityToken,proto3" json:"identity_token,omitempty"` // RegistryToken is a bearer token to be sent to a registry RegistryToken string `protobuf:"bytes,6,opt,name=registry_token,json=registryToken,proto3" json:"registry_token,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *AuthConfig) Reset() { *m = AuthConfig{} } func (*AuthConfig) ProtoMessage() {} func (*AuthConfig) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{101} } func (m *AuthConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *AuthConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_AuthConfig.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 *AuthConfig) XXX_Merge(src proto.Message) { xxx_messageInfo_AuthConfig.Merge(m, src) } func (m *AuthConfig) XXX_Size() int { return m.Size() } func (m *AuthConfig) XXX_DiscardUnknown() { xxx_messageInfo_AuthConfig.DiscardUnknown(m) } var xxx_messageInfo_AuthConfig proto.InternalMessageInfo func (m *AuthConfig) GetUsername() string { if m != nil { return m.Username } return "" } func (m *AuthConfig) GetPassword() string { if m != nil { return m.Password } return "" } func (m *AuthConfig) GetAuth() string { if m != nil { return m.Auth } return "" } func (m *AuthConfig) GetServerAddress() string { if m != nil { return m.ServerAddress } return "" } func (m *AuthConfig) GetIdentityToken() string { if m != nil { return m.IdentityToken } return "" } func (m *AuthConfig) GetRegistryToken() string { if m != nil { return m.RegistryToken } return "" } type PullImageRequest struct { // Spec of the image. Image *ImageSpec `protobuf:"bytes,1,opt,name=image,proto3" json:"image,omitempty"` // Authentication configuration for pulling the image. Auth *AuthConfig `protobuf:"bytes,2,opt,name=auth,proto3" json:"auth,omitempty"` // Config of the PodSandbox, which is used to pull image in PodSandbox context. SandboxConfig *PodSandboxConfig `protobuf:"bytes,3,opt,name=sandbox_config,json=sandboxConfig,proto3" json:"sandbox_config,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PullImageRequest) Reset() { *m = PullImageRequest{} } func (*PullImageRequest) ProtoMessage() {} func (*PullImageRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{102} } func (m *PullImageRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PullImageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PullImageRequest.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 *PullImageRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_PullImageRequest.Merge(m, src) } func (m *PullImageRequest) XXX_Size() int { return m.Size() } func (m *PullImageRequest) XXX_DiscardUnknown() { xxx_messageInfo_PullImageRequest.DiscardUnknown(m) } var xxx_messageInfo_PullImageRequest proto.InternalMessageInfo func (m *PullImageRequest) GetImage() *ImageSpec { if m != nil { return m.Image } return nil } func (m *PullImageRequest) GetAuth() *AuthConfig { if m != nil { return m.Auth } return nil } func (m *PullImageRequest) GetSandboxConfig() *PodSandboxConfig { if m != nil { return m.SandboxConfig } return nil } type PullImageResponse struct { // Reference to the image in use. For most runtimes, this should be an // image ID or digest. ImageRef string `protobuf:"bytes,1,opt,name=image_ref,json=imageRef,proto3" json:"image_ref,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PullImageResponse) Reset() { *m = PullImageResponse{} } func (*PullImageResponse) ProtoMessage() {} func (*PullImageResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{103} } func (m *PullImageResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PullImageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PullImageResponse.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 *PullImageResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_PullImageResponse.Merge(m, src) } func (m *PullImageResponse) XXX_Size() int { return m.Size() } func (m *PullImageResponse) XXX_DiscardUnknown() { xxx_messageInfo_PullImageResponse.DiscardUnknown(m) } var xxx_messageInfo_PullImageResponse proto.InternalMessageInfo func (m *PullImageResponse) GetImageRef() string { if m != nil { return m.ImageRef } return "" } type RemoveImageRequest struct { // Spec of the image to remove. Image *ImageSpec `protobuf:"bytes,1,opt,name=image,proto3" json:"image,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RemoveImageRequest) Reset() { *m = RemoveImageRequest{} } func (*RemoveImageRequest) ProtoMessage() {} func (*RemoveImageRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{104} } func (m *RemoveImageRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RemoveImageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RemoveImageRequest.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 *RemoveImageRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_RemoveImageRequest.Merge(m, src) } func (m *RemoveImageRequest) XXX_Size() int { return m.Size() } func (m *RemoveImageRequest) XXX_DiscardUnknown() { xxx_messageInfo_RemoveImageRequest.DiscardUnknown(m) } var xxx_messageInfo_RemoveImageRequest proto.InternalMessageInfo func (m *RemoveImageRequest) GetImage() *ImageSpec { if m != nil { return m.Image } return nil } type RemoveImageResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RemoveImageResponse) Reset() { *m = RemoveImageResponse{} } func (*RemoveImageResponse) ProtoMessage() {} func (*RemoveImageResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{105} } func (m *RemoveImageResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RemoveImageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RemoveImageResponse.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 *RemoveImageResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_RemoveImageResponse.Merge(m, src) } func (m *RemoveImageResponse) XXX_Size() int { return m.Size() } func (m *RemoveImageResponse) XXX_DiscardUnknown() { xxx_messageInfo_RemoveImageResponse.DiscardUnknown(m) } var xxx_messageInfo_RemoveImageResponse proto.InternalMessageInfo type NetworkConfig struct { // CIDR to use for pod IP addresses. If the CIDR is empty, runtimes // should omit it. PodCidr string `protobuf:"bytes,1,opt,name=pod_cidr,json=podCidr,proto3" json:"pod_cidr,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *NetworkConfig) Reset() { *m = NetworkConfig{} } func (*NetworkConfig) ProtoMessage() {} func (*NetworkConfig) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{106} } func (m *NetworkConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *NetworkConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_NetworkConfig.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 *NetworkConfig) XXX_Merge(src proto.Message) { xxx_messageInfo_NetworkConfig.Merge(m, src) } func (m *NetworkConfig) XXX_Size() int { return m.Size() } func (m *NetworkConfig) XXX_DiscardUnknown() { xxx_messageInfo_NetworkConfig.DiscardUnknown(m) } var xxx_messageInfo_NetworkConfig proto.InternalMessageInfo func (m *NetworkConfig) GetPodCidr() string { if m != nil { return m.PodCidr } return "" } type RuntimeConfig struct { NetworkConfig *NetworkConfig `protobuf:"bytes,1,opt,name=network_config,json=networkConfig,proto3" json:"network_config,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RuntimeConfig) Reset() { *m = RuntimeConfig{} } func (*RuntimeConfig) ProtoMessage() {} func (*RuntimeConfig) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{107} } func (m *RuntimeConfig) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RuntimeConfig) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RuntimeConfig.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 *RuntimeConfig) XXX_Merge(src proto.Message) { xxx_messageInfo_RuntimeConfig.Merge(m, src) } func (m *RuntimeConfig) XXX_Size() int { return m.Size() } func (m *RuntimeConfig) XXX_DiscardUnknown() { xxx_messageInfo_RuntimeConfig.DiscardUnknown(m) } var xxx_messageInfo_RuntimeConfig proto.InternalMessageInfo func (m *RuntimeConfig) GetNetworkConfig() *NetworkConfig { if m != nil { return m.NetworkConfig } return nil } type UpdateRuntimeConfigRequest struct { RuntimeConfig *RuntimeConfig `protobuf:"bytes,1,opt,name=runtime_config,json=runtimeConfig,proto3" json:"runtime_config,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *UpdateRuntimeConfigRequest) Reset() { *m = UpdateRuntimeConfigRequest{} } func (*UpdateRuntimeConfigRequest) ProtoMessage() {} func (*UpdateRuntimeConfigRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{108} } func (m *UpdateRuntimeConfigRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *UpdateRuntimeConfigRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_UpdateRuntimeConfigRequest.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 *UpdateRuntimeConfigRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_UpdateRuntimeConfigRequest.Merge(m, src) } func (m *UpdateRuntimeConfigRequest) XXX_Size() int { return m.Size() } func (m *UpdateRuntimeConfigRequest) XXX_DiscardUnknown() { xxx_messageInfo_UpdateRuntimeConfigRequest.DiscardUnknown(m) } var xxx_messageInfo_UpdateRuntimeConfigRequest proto.InternalMessageInfo func (m *UpdateRuntimeConfigRequest) GetRuntimeConfig() *RuntimeConfig { if m != nil { return m.RuntimeConfig } return nil } type UpdateRuntimeConfigResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *UpdateRuntimeConfigResponse) Reset() { *m = UpdateRuntimeConfigResponse{} } func (*UpdateRuntimeConfigResponse) ProtoMessage() {} func (*UpdateRuntimeConfigResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{109} } func (m *UpdateRuntimeConfigResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *UpdateRuntimeConfigResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_UpdateRuntimeConfigResponse.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 *UpdateRuntimeConfigResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_UpdateRuntimeConfigResponse.Merge(m, src) } func (m *UpdateRuntimeConfigResponse) XXX_Size() int { return m.Size() } func (m *UpdateRuntimeConfigResponse) XXX_DiscardUnknown() { xxx_messageInfo_UpdateRuntimeConfigResponse.DiscardUnknown(m) } var xxx_messageInfo_UpdateRuntimeConfigResponse proto.InternalMessageInfo // RuntimeCondition contains condition information for the runtime. // There are 2 kinds of runtime conditions: // 1. Required conditions: Conditions are required for kubelet to work // properly. If any required condition is unmet, the node will be not ready. // The required conditions include: // - RuntimeReady: RuntimeReady means the runtime is up and ready to accept // basic containers e.g. container only needs host network. // - NetworkReady: NetworkReady means the runtime network is up and ready to // accept containers which require container network. // // 2. Optional conditions: Conditions are informative to the user, but kubelet // will not rely on. Since condition type is an arbitrary string, all conditions // not required are optional. These conditions will be exposed to users to help // them understand the status of the system. type RuntimeCondition struct { // Type of runtime condition. Type string `protobuf:"bytes,1,opt,name=type,proto3" json:"type,omitempty"` // Status of the condition, one of true/false. Default: false. Status bool `protobuf:"varint,2,opt,name=status,proto3" json:"status,omitempty"` // Brief CamelCase string containing reason for the condition's last transition. Reason string `protobuf:"bytes,3,opt,name=reason,proto3" json:"reason,omitempty"` // Human-readable message indicating details about last transition. Message string `protobuf:"bytes,4,opt,name=message,proto3" json:"message,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RuntimeCondition) Reset() { *m = RuntimeCondition{} } func (*RuntimeCondition) ProtoMessage() {} func (*RuntimeCondition) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{110} } func (m *RuntimeCondition) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RuntimeCondition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RuntimeCondition.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 *RuntimeCondition) XXX_Merge(src proto.Message) { xxx_messageInfo_RuntimeCondition.Merge(m, src) } func (m *RuntimeCondition) XXX_Size() int { return m.Size() } func (m *RuntimeCondition) XXX_DiscardUnknown() { xxx_messageInfo_RuntimeCondition.DiscardUnknown(m) } var xxx_messageInfo_RuntimeCondition proto.InternalMessageInfo func (m *RuntimeCondition) GetType() string { if m != nil { return m.Type } return "" } func (m *RuntimeCondition) GetStatus() bool { if m != nil { return m.Status } return false } func (m *RuntimeCondition) GetReason() string { if m != nil { return m.Reason } return "" } func (m *RuntimeCondition) GetMessage() string { if m != nil { return m.Message } return "" } // RuntimeStatus is information about the current status of the runtime. type RuntimeStatus struct { // List of current observed runtime conditions. Conditions []*RuntimeCondition `protobuf:"bytes,1,rep,name=conditions,proto3" json:"conditions,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *RuntimeStatus) Reset() { *m = RuntimeStatus{} } func (*RuntimeStatus) ProtoMessage() {} func (*RuntimeStatus) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{111} } func (m *RuntimeStatus) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *RuntimeStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_RuntimeStatus.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 *RuntimeStatus) XXX_Merge(src proto.Message) { xxx_messageInfo_RuntimeStatus.Merge(m, src) } func (m *RuntimeStatus) XXX_Size() int { return m.Size() } func (m *RuntimeStatus) XXX_DiscardUnknown() { xxx_messageInfo_RuntimeStatus.DiscardUnknown(m) } var xxx_messageInfo_RuntimeStatus proto.InternalMessageInfo func (m *RuntimeStatus) GetConditions() []*RuntimeCondition { if m != nil { return m.Conditions } return nil } type StatusRequest struct { // Verbose indicates whether to return extra information about the runtime. Verbose bool `protobuf:"varint,1,opt,name=verbose,proto3" json:"verbose,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *StatusRequest) Reset() { *m = StatusRequest{} } func (*StatusRequest) ProtoMessage() {} func (*StatusRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{112} } func (m *StatusRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *StatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_StatusRequest.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 *StatusRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_StatusRequest.Merge(m, src) } func (m *StatusRequest) XXX_Size() int { return m.Size() } func (m *StatusRequest) XXX_DiscardUnknown() { xxx_messageInfo_StatusRequest.DiscardUnknown(m) } var xxx_messageInfo_StatusRequest proto.InternalMessageInfo func (m *StatusRequest) GetVerbose() bool { if m != nil { return m.Verbose } 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{113} } 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{114} } 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{115} } 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"` // Info is extra information of the Runtime. The key could be arbitrary string, and // 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"` // 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{116} } func (m *StatusResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *StatusResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_StatusResponse.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 *StatusResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_StatusResponse.Merge(m, src) } func (m *StatusResponse) XXX_Size() int { return m.Size() } func (m *StatusResponse) XXX_DiscardUnknown() { xxx_messageInfo_StatusResponse.DiscardUnknown(m) } var xxx_messageInfo_StatusResponse proto.InternalMessageInfo func (m *StatusResponse) GetStatus() *RuntimeStatus { if m != nil { return m.Status } return nil } func (m *StatusResponse) GetInfo() map[string]string { if m != nil { return m.Info } 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:"-"` } func (m *ImageFsInfoRequest) Reset() { *m = ImageFsInfoRequest{} } func (*ImageFsInfoRequest) ProtoMessage() {} func (*ImageFsInfoRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{117} } func (m *ImageFsInfoRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ImageFsInfoRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ImageFsInfoRequest.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 *ImageFsInfoRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ImageFsInfoRequest.Merge(m, src) } func (m *ImageFsInfoRequest) XXX_Size() int { return m.Size() } func (m *ImageFsInfoRequest) XXX_DiscardUnknown() { xxx_messageInfo_ImageFsInfoRequest.DiscardUnknown(m) } var xxx_messageInfo_ImageFsInfoRequest proto.InternalMessageInfo // UInt64Value is the wrapper of uint64. type UInt64Value struct { // The value. Value uint64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *UInt64Value) Reset() { *m = UInt64Value{} } func (*UInt64Value) ProtoMessage() {} func (*UInt64Value) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{118} } func (m *UInt64Value) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *UInt64Value) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_UInt64Value.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 *UInt64Value) XXX_Merge(src proto.Message) { xxx_messageInfo_UInt64Value.Merge(m, src) } func (m *UInt64Value) XXX_Size() int { return m.Size() } func (m *UInt64Value) XXX_DiscardUnknown() { xxx_messageInfo_UInt64Value.DiscardUnknown(m) } var xxx_messageInfo_UInt64Value proto.InternalMessageInfo func (m *UInt64Value) GetValue() uint64 { if m != nil { return m.Value } return 0 } // FilesystemIdentifier uniquely identify the filesystem. type FilesystemIdentifier struct { // Mountpoint of a filesystem. Mountpoint string `protobuf:"bytes,1,opt,name=mountpoint,proto3" json:"mountpoint,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *FilesystemIdentifier) Reset() { *m = FilesystemIdentifier{} } func (*FilesystemIdentifier) ProtoMessage() {} func (*FilesystemIdentifier) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{119} } func (m *FilesystemIdentifier) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *FilesystemIdentifier) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_FilesystemIdentifier.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 *FilesystemIdentifier) XXX_Merge(src proto.Message) { xxx_messageInfo_FilesystemIdentifier.Merge(m, src) } func (m *FilesystemIdentifier) XXX_Size() int { return m.Size() } func (m *FilesystemIdentifier) XXX_DiscardUnknown() { xxx_messageInfo_FilesystemIdentifier.DiscardUnknown(m) } var xxx_messageInfo_FilesystemIdentifier proto.InternalMessageInfo func (m *FilesystemIdentifier) GetMountpoint() string { if m != nil { return m.Mountpoint } return "" } // FilesystemUsage provides the filesystem usage information. type FilesystemUsage 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 unique identifier of the filesystem. FsId *FilesystemIdentifier `protobuf:"bytes,2,opt,name=fs_id,json=fsId,proto3" json:"fs_id,omitempty"` // UsedBytes represents the bytes used for images on the filesystem. // This may differ from the total bytes used on the filesystem and may not // equal CapacityBytes - AvailableBytes. UsedBytes *UInt64Value `protobuf:"bytes,3,opt,name=used_bytes,json=usedBytes,proto3" json:"used_bytes,omitempty"` // InodesUsed represents the inodes used by the images. // This may not equal InodesCapacity - InodesAvailable because the underlying // filesystem may also be used for purposes other than storing images. InodesUsed *UInt64Value `protobuf:"bytes,4,opt,name=inodes_used,json=inodesUsed,proto3" json:"inodes_used,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *FilesystemUsage) Reset() { *m = FilesystemUsage{} } func (*FilesystemUsage) ProtoMessage() {} func (*FilesystemUsage) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{120} } func (m *FilesystemUsage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *FilesystemUsage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_FilesystemUsage.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 *FilesystemUsage) XXX_Merge(src proto.Message) { xxx_messageInfo_FilesystemUsage.Merge(m, src) } func (m *FilesystemUsage) XXX_Size() int { return m.Size() } func (m *FilesystemUsage) XXX_DiscardUnknown() { xxx_messageInfo_FilesystemUsage.DiscardUnknown(m) } var xxx_messageInfo_FilesystemUsage proto.InternalMessageInfo func (m *FilesystemUsage) GetTimestamp() int64 { if m != nil { return m.Timestamp } return 0 } func (m *FilesystemUsage) GetFsId() *FilesystemIdentifier { if m != nil { return m.FsId } return nil } func (m *FilesystemUsage) GetUsedBytes() *UInt64Value { if m != nil { return m.UsedBytes } return nil } func (m *FilesystemUsage) GetInodesUsed() *UInt64Value { if m != nil { return m.InodesUsed } return nil } // WindowsFilesystemUsage provides the filesystem usage information specific to Windows. type WindowsFilesystemUsage 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 unique identifier of the filesystem. FsId *FilesystemIdentifier `protobuf:"bytes,2,opt,name=fs_id,json=fsId,proto3" json:"fs_id,omitempty"` // UsedBytes represents the bytes used for images on the filesystem. // This may differ from the total bytes used on the filesystem and may not // equal CapacityBytes - AvailableBytes. UsedBytes *UInt64Value `protobuf:"bytes,3,opt,name=used_bytes,json=usedBytes,proto3" json:"used_bytes,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WindowsFilesystemUsage) Reset() { *m = WindowsFilesystemUsage{} } func (*WindowsFilesystemUsage) ProtoMessage() {} func (*WindowsFilesystemUsage) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{121} } func (m *WindowsFilesystemUsage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WindowsFilesystemUsage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WindowsFilesystemUsage.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 *WindowsFilesystemUsage) XXX_Merge(src proto.Message) { xxx_messageInfo_WindowsFilesystemUsage.Merge(m, src) } func (m *WindowsFilesystemUsage) XXX_Size() int { return m.Size() } func (m *WindowsFilesystemUsage) XXX_DiscardUnknown() { xxx_messageInfo_WindowsFilesystemUsage.DiscardUnknown(m) } var xxx_messageInfo_WindowsFilesystemUsage proto.InternalMessageInfo func (m *WindowsFilesystemUsage) GetTimestamp() int64 { if m != nil { return m.Timestamp } return 0 } func (m *WindowsFilesystemUsage) GetFsId() *FilesystemIdentifier { if m != nil { return m.FsId } return nil } func (m *WindowsFilesystemUsage) GetUsedBytes() *UInt64Value { if m != nil { return m.UsedBytes } return nil } type ImageFsInfoResponse struct { // Information of image filesystem(s). 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:"-"` } func (m *ImageFsInfoResponse) Reset() { *m = ImageFsInfoResponse{} } func (*ImageFsInfoResponse) ProtoMessage() {} func (*ImageFsInfoResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{122} } func (m *ImageFsInfoResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ImageFsInfoResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ImageFsInfoResponse.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 *ImageFsInfoResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ImageFsInfoResponse.Merge(m, src) } func (m *ImageFsInfoResponse) XXX_Size() int { return m.Size() } func (m *ImageFsInfoResponse) XXX_DiscardUnknown() { xxx_messageInfo_ImageFsInfoResponse.DiscardUnknown(m) } var xxx_messageInfo_ImageFsInfoResponse proto.InternalMessageInfo func (m *ImageFsInfoResponse) GetImageFilesystems() []*FilesystemUsage { if m != nil { return m.ImageFilesystems } 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"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ContainerStatsRequest) Reset() { *m = ContainerStatsRequest{} } func (*ContainerStatsRequest) ProtoMessage() {} func (*ContainerStatsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{123} } func (m *ContainerStatsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ContainerStatsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ContainerStatsRequest.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 *ContainerStatsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ContainerStatsRequest.Merge(m, src) } func (m *ContainerStatsRequest) XXX_Size() int { return m.Size() } func (m *ContainerStatsRequest) XXX_DiscardUnknown() { xxx_messageInfo_ContainerStatsRequest.DiscardUnknown(m) } var xxx_messageInfo_ContainerStatsRequest proto.InternalMessageInfo func (m *ContainerStatsRequest) GetContainerId() string { if m != nil { return m.ContainerId } return "" } type ContainerStatsResponse struct { // Stats of the container. Stats *ContainerStats `protobuf:"bytes,1,opt,name=stats,proto3" json:"stats,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ContainerStatsResponse) Reset() { *m = ContainerStatsResponse{} } func (*ContainerStatsResponse) ProtoMessage() {} func (*ContainerStatsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{124} } func (m *ContainerStatsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ContainerStatsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ContainerStatsResponse.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 *ContainerStatsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ContainerStatsResponse.Merge(m, src) } func (m *ContainerStatsResponse) XXX_Size() int { return m.Size() } func (m *ContainerStatsResponse) XXX_DiscardUnknown() { xxx_messageInfo_ContainerStatsResponse.DiscardUnknown(m) } var xxx_messageInfo_ContainerStatsResponse proto.InternalMessageInfo func (m *ContainerStatsResponse) GetStats() *ContainerStats { if m != nil { return m.Stats } return nil } type ListContainerStatsRequest struct { // Filter for the list request. Filter *ContainerStatsFilter `protobuf:"bytes,1,opt,name=filter,proto3" json:"filter,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListContainerStatsRequest) Reset() { *m = ListContainerStatsRequest{} } func (*ListContainerStatsRequest) ProtoMessage() {} func (*ListContainerStatsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{125} } func (m *ListContainerStatsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListContainerStatsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListContainerStatsRequest.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 *ListContainerStatsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ListContainerStatsRequest.Merge(m, src) } func (m *ListContainerStatsRequest) XXX_Size() int { return m.Size() } func (m *ListContainerStatsRequest) XXX_DiscardUnknown() { xxx_messageInfo_ListContainerStatsRequest.DiscardUnknown(m) } var xxx_messageInfo_ListContainerStatsRequest proto.InternalMessageInfo func (m *ListContainerStatsRequest) GetFilter() *ContainerStatsFilter { if m != nil { return m.Filter } return nil } // ContainerStatsFilter is used to filter containers. // All those fields are combined with 'AND' type ContainerStatsFilter struct { // ID of the container. Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` // ID of the PodSandbox. PodSandboxId string `protobuf:"bytes,2,opt,name=pod_sandbox_id,json=podSandboxId,proto3" json:"pod_sandbox_id,omitempty"` // LabelSelector to select matches. // Only api.MatchLabels is supported for now and the requirements // are ANDed. MatchExpressions is not supported yet. LabelSelector map[string]string `protobuf:"bytes,3,rep,name=label_selector,json=labelSelector,proto3" json:"label_selector,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:"-"` } func (m *ContainerStatsFilter) Reset() { *m = ContainerStatsFilter{} } func (*ContainerStatsFilter) ProtoMessage() {} func (*ContainerStatsFilter) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{126} } func (m *ContainerStatsFilter) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ContainerStatsFilter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ContainerStatsFilter.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 *ContainerStatsFilter) XXX_Merge(src proto.Message) { xxx_messageInfo_ContainerStatsFilter.Merge(m, src) } func (m *ContainerStatsFilter) XXX_Size() int { return m.Size() } func (m *ContainerStatsFilter) XXX_DiscardUnknown() { xxx_messageInfo_ContainerStatsFilter.DiscardUnknown(m) } var xxx_messageInfo_ContainerStatsFilter proto.InternalMessageInfo func (m *ContainerStatsFilter) GetId() string { if m != nil { return m.Id } return "" } func (m *ContainerStatsFilter) GetPodSandboxId() string { if m != nil { return m.PodSandboxId } return "" } func (m *ContainerStatsFilter) GetLabelSelector() map[string]string { if m != nil { return m.LabelSelector } return nil } type ListContainerStatsResponse struct { // Stats of the container. Stats []*ContainerStats `protobuf:"bytes,1,rep,name=stats,proto3" json:"stats,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListContainerStatsResponse) Reset() { *m = ListContainerStatsResponse{} } func (*ListContainerStatsResponse) ProtoMessage() {} func (*ListContainerStatsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{127} } func (m *ListContainerStatsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListContainerStatsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListContainerStatsResponse.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 *ListContainerStatsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ListContainerStatsResponse.Merge(m, src) } func (m *ListContainerStatsResponse) XXX_Size() int { return m.Size() } func (m *ListContainerStatsResponse) XXX_DiscardUnknown() { xxx_messageInfo_ListContainerStatsResponse.DiscardUnknown(m) } var xxx_messageInfo_ListContainerStatsResponse proto.InternalMessageInfo func (m *ListContainerStatsResponse) GetStats() []*ContainerStats { if m != nil { return m.Stats } return nil } // ContainerAttributes provides basic information of the container. type ContainerAttributes struct { // ID of the container. Id string `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"` // Metadata of the container. Metadata *ContainerMetadata `protobuf:"bytes,2,opt,name=metadata,proto3" json:"metadata,omitempty"` // Key-value pairs that may be used to scope and select individual resources. Labels map[string]string `protobuf:"bytes,3,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"` // Unstructured key-value map holding arbitrary metadata. // 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 the Container this status represents. Annotations map[string]string `protobuf:"bytes,4,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:"-"` } func (m *ContainerAttributes) Reset() { *m = ContainerAttributes{} } func (*ContainerAttributes) ProtoMessage() {} func (*ContainerAttributes) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{128} } func (m *ContainerAttributes) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ContainerAttributes) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ContainerAttributes.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 *ContainerAttributes) XXX_Merge(src proto.Message) { xxx_messageInfo_ContainerAttributes.Merge(m, src) } func (m *ContainerAttributes) XXX_Size() int { return m.Size() } func (m *ContainerAttributes) XXX_DiscardUnknown() { xxx_messageInfo_ContainerAttributes.DiscardUnknown(m) } var xxx_messageInfo_ContainerAttributes proto.InternalMessageInfo func (m *ContainerAttributes) GetId() string { if m != nil { return m.Id } return "" } func (m *ContainerAttributes) GetMetadata() *ContainerMetadata { if m != nil { return m.Metadata } return nil } func (m *ContainerAttributes) GetLabels() map[string]string { if m != nil { return m.Labels } return nil } func (m *ContainerAttributes) GetAnnotations() map[string]string { if m != nil { return m.Annotations } return nil } // ContainerStats provides the resource usage statistics for a container. type ContainerStats struct { // Information of the container. Attributes *ContainerAttributes `protobuf:"bytes,1,opt,name=attributes,proto3" json:"attributes,omitempty"` // CPU usage gathered from the container. Cpu *CpuUsage `protobuf:"bytes,2,opt,name=cpu,proto3" json:"cpu,omitempty"` // 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"` // 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{129} } func (m *ContainerStats) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ContainerStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ContainerStats.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 *ContainerStats) XXX_Merge(src proto.Message) { xxx_messageInfo_ContainerStats.Merge(m, src) } func (m *ContainerStats) XXX_Size() int { return m.Size() } func (m *ContainerStats) XXX_DiscardUnknown() { xxx_messageInfo_ContainerStats.DiscardUnknown(m) } var xxx_messageInfo_ContainerStats proto.InternalMessageInfo func (m *ContainerStats) GetAttributes() *ContainerAttributes { if m != nil { return m.Attributes } return nil } func (m *ContainerStats) GetCpu() *CpuUsage { if m != nil { return m.Cpu } return nil } func (m *ContainerStats) GetMemory() *MemoryUsage { if m != nil { return m.Memory } return nil } func (m *ContainerStats) GetWritableLayer() *FilesystemUsage { if m != nil { return m.WritableLayer } 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. Attributes *ContainerAttributes `protobuf:"bytes,1,opt,name=attributes,proto3" json:"attributes,omitempty"` // CPU usage gathered from the container. Cpu *WindowsCpuUsage `protobuf:"bytes,2,opt,name=cpu,proto3" json:"cpu,omitempty"` // Memory usage gathered from the container. Memory *WindowsMemoryUsage `protobuf:"bytes,3,opt,name=memory,proto3" json:"memory,omitempty"` // Usage of the writable layer. WritableLayer *WindowsFilesystemUsage `protobuf:"bytes,4,opt,name=writable_layer,json=writableLayer,proto3" json:"writable_layer,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WindowsContainerStats) Reset() { *m = WindowsContainerStats{} } func (*WindowsContainerStats) ProtoMessage() {} func (*WindowsContainerStats) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{130} } func (m *WindowsContainerStats) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WindowsContainerStats) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WindowsContainerStats.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 *WindowsContainerStats) XXX_Merge(src proto.Message) { xxx_messageInfo_WindowsContainerStats.Merge(m, src) } func (m *WindowsContainerStats) XXX_Size() int { return m.Size() } func (m *WindowsContainerStats) XXX_DiscardUnknown() { xxx_messageInfo_WindowsContainerStats.DiscardUnknown(m) } var xxx_messageInfo_WindowsContainerStats proto.InternalMessageInfo func (m *WindowsContainerStats) GetAttributes() *ContainerAttributes { if m != nil { return m.Attributes } return nil } func (m *WindowsContainerStats) GetCpu() *WindowsCpuUsage { if m != nil { return m.Cpu } return nil } func (m *WindowsContainerStats) GetMemory() *WindowsMemoryUsage { if m != nil { return m.Memory } return nil } func (m *WindowsContainerStats) GetWritableLayer() *WindowsFilesystemUsage { if m != nil { return m.WritableLayer } return nil } // CpuUsage provides the CPU usage information. type CpuUsage 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"` // Cumulative CPU usage (sum across all cores) since object creation. UsageCoreNanoSeconds *UInt64Value `protobuf:"bytes,2,opt,name=usage_core_nano_seconds,json=usageCoreNanoSeconds,proto3" json:"usage_core_nano_seconds,omitempty"` // Total CPU usage (sum of all cores) averaged over the sample window. // The "core" unit can be interpreted as CPU core-nanoseconds per second. UsageNanoCores *UInt64Value `protobuf:"bytes,3,opt,name=usage_nano_cores,json=usageNanoCores,proto3" json:"usage_nano_cores,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CpuUsage) Reset() { *m = CpuUsage{} } func (*CpuUsage) ProtoMessage() {} func (*CpuUsage) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{131} } func (m *CpuUsage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CpuUsage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CpuUsage.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 *CpuUsage) XXX_Merge(src proto.Message) { xxx_messageInfo_CpuUsage.Merge(m, src) } func (m *CpuUsage) XXX_Size() int { return m.Size() } func (m *CpuUsage) XXX_DiscardUnknown() { xxx_messageInfo_CpuUsage.DiscardUnknown(m) } var xxx_messageInfo_CpuUsage proto.InternalMessageInfo func (m *CpuUsage) GetTimestamp() int64 { if m != nil { return m.Timestamp } return 0 } func (m *CpuUsage) GetUsageCoreNanoSeconds() *UInt64Value { if m != nil { return m.UsageCoreNanoSeconds } return nil } func (m *CpuUsage) GetUsageNanoCores() *UInt64Value { if m != nil { return m.UsageNanoCores } return nil } // WindowsCpuUsage provides the CPU usage information specific to Windows type WindowsCpuUsage 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"` // Cumulative CPU usage (sum across all cores) since object creation. UsageCoreNanoSeconds *UInt64Value `protobuf:"bytes,2,opt,name=usage_core_nano_seconds,json=usageCoreNanoSeconds,proto3" json:"usage_core_nano_seconds,omitempty"` // Total CPU usage (sum of all cores) averaged over the sample window. // The "core" unit can be interpreted as CPU core-nanoseconds per second. UsageNanoCores *UInt64Value `protobuf:"bytes,3,opt,name=usage_nano_cores,json=usageNanoCores,proto3" json:"usage_nano_cores,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *WindowsCpuUsage) Reset() { *m = WindowsCpuUsage{} } func (*WindowsCpuUsage) ProtoMessage() {} func (*WindowsCpuUsage) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{132} } func (m *WindowsCpuUsage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WindowsCpuUsage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WindowsCpuUsage.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 *WindowsCpuUsage) XXX_Merge(src proto.Message) { xxx_messageInfo_WindowsCpuUsage.Merge(m, src) } func (m *WindowsCpuUsage) XXX_Size() int { return m.Size() } func (m *WindowsCpuUsage) XXX_DiscardUnknown() { xxx_messageInfo_WindowsCpuUsage.DiscardUnknown(m) } var xxx_messageInfo_WindowsCpuUsage proto.InternalMessageInfo func (m *WindowsCpuUsage) GetTimestamp() int64 { if m != nil { return m.Timestamp } return 0 } func (m *WindowsCpuUsage) GetUsageCoreNanoSeconds() *UInt64Value { if m != nil { return m.UsageCoreNanoSeconds } return nil } func (m *WindowsCpuUsage) GetUsageNanoCores() *UInt64Value { if m != nil { return m.UsageNanoCores } return nil } // MemoryUsage provides the memory usage information. type MemoryUsage 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. AvailableBytes *UInt64Value `protobuf:"bytes,3,opt,name=available_bytes,json=availableBytes,proto3" json:"available_bytes,omitempty"` // Total memory in use. This includes all memory regardless of when it was accessed. UsageBytes *UInt64Value `protobuf:"bytes,4,opt,name=usage_bytes,json=usageBytes,proto3" json:"usage_bytes,omitempty"` // The amount of anonymous and swap cache memory (includes transparent hugepages). RssBytes *UInt64Value `protobuf:"bytes,5,opt,name=rss_bytes,json=rssBytes,proto3" json:"rss_bytes,omitempty"` // Cumulative number of minor page faults. PageFaults *UInt64Value `protobuf:"bytes,6,opt,name=page_faults,json=pageFaults,proto3" json:"page_faults,omitempty"` // Cumulative number of major page faults. MajorPageFaults *UInt64Value `protobuf:"bytes,7,opt,name=major_page_faults,json=majorPageFaults,proto3" json:"major_page_faults,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *MemoryUsage) Reset() { *m = MemoryUsage{} } func (*MemoryUsage) ProtoMessage() {} func (*MemoryUsage) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{133} } func (m *MemoryUsage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *MemoryUsage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MemoryUsage.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 *MemoryUsage) XXX_Merge(src proto.Message) { xxx_messageInfo_MemoryUsage.Merge(m, src) } func (m *MemoryUsage) XXX_Size() int { return m.Size() } func (m *MemoryUsage) XXX_DiscardUnknown() { xxx_messageInfo_MemoryUsage.DiscardUnknown(m) } var xxx_messageInfo_MemoryUsage proto.InternalMessageInfo func (m *MemoryUsage) GetTimestamp() int64 { if m != nil { return m.Timestamp } return 0 } func (m *MemoryUsage) GetWorkingSetBytes() *UInt64Value { if m != nil { return m.WorkingSetBytes } return nil } func (m *MemoryUsage) GetAvailableBytes() *UInt64Value { if m != nil { return m.AvailableBytes } return nil } func (m *MemoryUsage) GetUsageBytes() *UInt64Value { if m != nil { return m.UsageBytes } return nil } func (m *MemoryUsage) GetRssBytes() *UInt64Value { if m != nil { return m.RssBytes } return nil } func (m *MemoryUsage) GetPageFaults() *UInt64Value { if m != nil { return m.PageFaults } return nil } func (m *MemoryUsage) GetMajorPageFaults() *UInt64Value { if m != nil { return m.MajorPageFaults } 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{134} } 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 - 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"` // 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:"-"` } func (m *WindowsMemoryUsage) Reset() { *m = WindowsMemoryUsage{} } func (*WindowsMemoryUsage) ProtoMessage() {} func (*WindowsMemoryUsage) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{135} } func (m *WindowsMemoryUsage) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *WindowsMemoryUsage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_WindowsMemoryUsage.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 *WindowsMemoryUsage) XXX_Merge(src proto.Message) { xxx_messageInfo_WindowsMemoryUsage.Merge(m, src) } func (m *WindowsMemoryUsage) XXX_Size() int { return m.Size() } func (m *WindowsMemoryUsage) XXX_DiscardUnknown() { xxx_messageInfo_WindowsMemoryUsage.DiscardUnknown(m) } var xxx_messageInfo_WindowsMemoryUsage proto.InternalMessageInfo func (m *WindowsMemoryUsage) GetTimestamp() int64 { if m != nil { return m.Timestamp } return 0 } func (m *WindowsMemoryUsage) GetWorkingSetBytes() *UInt64Value { if m != nil { return m.WorkingSetBytes } return nil } func (m *WindowsMemoryUsage) GetAvailableBytes() *UInt64Value { if m != nil { return m.AvailableBytes } return nil } func (m *WindowsMemoryUsage) GetPageFaults() *UInt64Value { if m != nil { return m.PageFaults } 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"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ReopenContainerLogRequest) Reset() { *m = ReopenContainerLogRequest{} } func (*ReopenContainerLogRequest) ProtoMessage() {} func (*ReopenContainerLogRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{136} } func (m *ReopenContainerLogRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ReopenContainerLogRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ReopenContainerLogRequest.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 *ReopenContainerLogRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ReopenContainerLogRequest.Merge(m, src) } func (m *ReopenContainerLogRequest) XXX_Size() int { return m.Size() } func (m *ReopenContainerLogRequest) XXX_DiscardUnknown() { xxx_messageInfo_ReopenContainerLogRequest.DiscardUnknown(m) } var xxx_messageInfo_ReopenContainerLogRequest proto.InternalMessageInfo func (m *ReopenContainerLogRequest) GetContainerId() string { if m != nil { return m.ContainerId } return "" } type ReopenContainerLogResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ReopenContainerLogResponse) Reset() { *m = ReopenContainerLogResponse{} } func (*ReopenContainerLogResponse) ProtoMessage() {} func (*ReopenContainerLogResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{137} } func (m *ReopenContainerLogResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ReopenContainerLogResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ReopenContainerLogResponse.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 *ReopenContainerLogResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ReopenContainerLogResponse.Merge(m, src) } func (m *ReopenContainerLogResponse) XXX_Size() int { return m.Size() } func (m *ReopenContainerLogResponse) XXX_DiscardUnknown() { xxx_messageInfo_ReopenContainerLogResponse.DiscardUnknown(m) } var xxx_messageInfo_ReopenContainerLogResponse proto.InternalMessageInfo type CheckpointContainerRequest struct { // ID of the container to be checkpointed. ContainerId string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` // Location of the checkpoint archive used for export Location string `protobuf:"bytes,2,opt,name=location,proto3" json:"location,omitempty"` // Timeout in seconds for the checkpoint to complete. // Timeout of zero means to use the CRI default. // Timeout > 0 means to use the user specified timeout. Timeout int64 `protobuf:"varint,3,opt,name=timeout,proto3" json:"timeout,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CheckpointContainerRequest) Reset() { *m = CheckpointContainerRequest{} } func (*CheckpointContainerRequest) ProtoMessage() {} func (*CheckpointContainerRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{138} } func (m *CheckpointContainerRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CheckpointContainerRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CheckpointContainerRequest.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 *CheckpointContainerRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_CheckpointContainerRequest.Merge(m, src) } func (m *CheckpointContainerRequest) XXX_Size() int { return m.Size() } func (m *CheckpointContainerRequest) XXX_DiscardUnknown() { xxx_messageInfo_CheckpointContainerRequest.DiscardUnknown(m) } var xxx_messageInfo_CheckpointContainerRequest proto.InternalMessageInfo func (m *CheckpointContainerRequest) GetContainerId() string { if m != nil { return m.ContainerId } return "" } func (m *CheckpointContainerRequest) GetLocation() string { if m != nil { return m.Location } return "" } func (m *CheckpointContainerRequest) GetTimeout() int64 { if m != nil { return m.Timeout } return 0 } type CheckpointContainerResponse struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *CheckpointContainerResponse) Reset() { *m = CheckpointContainerResponse{} } func (*CheckpointContainerResponse) ProtoMessage() {} func (*CheckpointContainerResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{139} } func (m *CheckpointContainerResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *CheckpointContainerResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_CheckpointContainerResponse.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 *CheckpointContainerResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_CheckpointContainerResponse.Merge(m, src) } func (m *CheckpointContainerResponse) XXX_Size() int { return m.Size() } func (m *CheckpointContainerResponse) XXX_DiscardUnknown() { xxx_messageInfo_CheckpointContainerResponse.DiscardUnknown(m) } var xxx_messageInfo_CheckpointContainerResponse proto.InternalMessageInfo type GetEventsRequest struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *GetEventsRequest) Reset() { *m = GetEventsRequest{} } func (*GetEventsRequest) ProtoMessage() {} func (*GetEventsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{140} } func (m *GetEventsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *GetEventsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_GetEventsRequest.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 *GetEventsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_GetEventsRequest.Merge(m, src) } func (m *GetEventsRequest) XXX_Size() int { return m.Size() } func (m *GetEventsRequest) XXX_DiscardUnknown() { xxx_messageInfo_GetEventsRequest.DiscardUnknown(m) } var xxx_messageInfo_GetEventsRequest proto.InternalMessageInfo type ContainerEventResponse struct { // ID of the container ContainerId string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` // Type of the container event ContainerEventType ContainerEventType `protobuf:"varint,2,opt,name=container_event_type,json=containerEventType,proto3,enum=runtime.v1.ContainerEventType" json:"container_event_type,omitempty"` // Creation timestamp in nanoseconds of this event CreatedAt int64 `protobuf:"varint,3,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"` // Sandbox status PodSandboxStatus *PodSandboxStatus `protobuf:"bytes,4,opt,name=pod_sandbox_status,json=podSandboxStatus,proto3" json:"pod_sandbox_status,omitempty"` // Container statuses ContainersStatuses []*ContainerStatus `protobuf:"bytes,5,rep,name=containers_statuses,json=containersStatuses,proto3" json:"containers_statuses,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ContainerEventResponse) Reset() { *m = ContainerEventResponse{} } func (*ContainerEventResponse) ProtoMessage() {} func (*ContainerEventResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{141} } func (m *ContainerEventResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ContainerEventResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ContainerEventResponse.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 *ContainerEventResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ContainerEventResponse.Merge(m, src) } func (m *ContainerEventResponse) XXX_Size() int { return m.Size() } func (m *ContainerEventResponse) XXX_DiscardUnknown() { xxx_messageInfo_ContainerEventResponse.DiscardUnknown(m) } var xxx_messageInfo_ContainerEventResponse proto.InternalMessageInfo func (m *ContainerEventResponse) GetContainerId() string { if m != nil { return m.ContainerId } return "" } func (m *ContainerEventResponse) GetContainerEventType() ContainerEventType { if m != nil { return m.ContainerEventType } return ContainerEventType_CONTAINER_CREATED_EVENT } func (m *ContainerEventResponse) GetCreatedAt() int64 { if m != nil { return m.CreatedAt } return 0 } func (m *ContainerEventResponse) GetPodSandboxStatus() *PodSandboxStatus { if m != nil { return m.PodSandboxStatus } return nil } func (m *ContainerEventResponse) GetContainersStatuses() []*ContainerStatus { if m != nil { return m.ContainersStatuses } return nil } type ListMetricDescriptorsRequest struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListMetricDescriptorsRequest) Reset() { *m = ListMetricDescriptorsRequest{} } func (*ListMetricDescriptorsRequest) ProtoMessage() {} func (*ListMetricDescriptorsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{142} } func (m *ListMetricDescriptorsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListMetricDescriptorsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListMetricDescriptorsRequest.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 *ListMetricDescriptorsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ListMetricDescriptorsRequest.Merge(m, src) } func (m *ListMetricDescriptorsRequest) XXX_Size() int { return m.Size() } func (m *ListMetricDescriptorsRequest) XXX_DiscardUnknown() { xxx_messageInfo_ListMetricDescriptorsRequest.DiscardUnknown(m) } var xxx_messageInfo_ListMetricDescriptorsRequest proto.InternalMessageInfo type ListMetricDescriptorsResponse struct { Descriptors []*MetricDescriptor `protobuf:"bytes,1,rep,name=descriptors,proto3" json:"descriptors,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListMetricDescriptorsResponse) Reset() { *m = ListMetricDescriptorsResponse{} } func (*ListMetricDescriptorsResponse) ProtoMessage() {} func (*ListMetricDescriptorsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{143} } func (m *ListMetricDescriptorsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListMetricDescriptorsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListMetricDescriptorsResponse.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 *ListMetricDescriptorsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ListMetricDescriptorsResponse.Merge(m, src) } func (m *ListMetricDescriptorsResponse) XXX_Size() int { return m.Size() } func (m *ListMetricDescriptorsResponse) XXX_DiscardUnknown() { xxx_messageInfo_ListMetricDescriptorsResponse.DiscardUnknown(m) } var xxx_messageInfo_ListMetricDescriptorsResponse proto.InternalMessageInfo func (m *ListMetricDescriptorsResponse) GetDescriptors() []*MetricDescriptor { if m != nil { return m.Descriptors } return nil } type MetricDescriptor struct { // The name field will be used as a unique identifier of this MetricDescriptor, // and be used in conjunction with the Metric structure to populate the full Metric. Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` Help string `protobuf:"bytes,2,opt,name=help,proto3" json:"help,omitempty"` // When a metric uses this metric descriptor, it should only define // labels that have previously been declared in label_keys. // It is the responsibility of the runtime to correctly keep sorted the keys and values. // If the two slices have different length, the behavior is undefined. LabelKeys []string `protobuf:"bytes,3,rep,name=label_keys,json=labelKeys,proto3" json:"label_keys,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *MetricDescriptor) Reset() { *m = MetricDescriptor{} } func (*MetricDescriptor) ProtoMessage() {} func (*MetricDescriptor) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{144} } func (m *MetricDescriptor) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *MetricDescriptor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_MetricDescriptor.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 *MetricDescriptor) XXX_Merge(src proto.Message) { xxx_messageInfo_MetricDescriptor.Merge(m, src) } func (m *MetricDescriptor) XXX_Size() int { return m.Size() } func (m *MetricDescriptor) XXX_DiscardUnknown() { xxx_messageInfo_MetricDescriptor.DiscardUnknown(m) } var xxx_messageInfo_MetricDescriptor proto.InternalMessageInfo func (m *MetricDescriptor) GetName() string { if m != nil { return m.Name } return "" } func (m *MetricDescriptor) GetHelp() string { if m != nil { return m.Help } return "" } func (m *MetricDescriptor) GetLabelKeys() []string { if m != nil { return m.LabelKeys } return nil } type ListPodSandboxMetricsRequest struct { XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListPodSandboxMetricsRequest) Reset() { *m = ListPodSandboxMetricsRequest{} } func (*ListPodSandboxMetricsRequest) ProtoMessage() {} func (*ListPodSandboxMetricsRequest) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{145} } func (m *ListPodSandboxMetricsRequest) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListPodSandboxMetricsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListPodSandboxMetricsRequest.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 *ListPodSandboxMetricsRequest) XXX_Merge(src proto.Message) { xxx_messageInfo_ListPodSandboxMetricsRequest.Merge(m, src) } func (m *ListPodSandboxMetricsRequest) XXX_Size() int { return m.Size() } func (m *ListPodSandboxMetricsRequest) XXX_DiscardUnknown() { xxx_messageInfo_ListPodSandboxMetricsRequest.DiscardUnknown(m) } var xxx_messageInfo_ListPodSandboxMetricsRequest proto.InternalMessageInfo type ListPodSandboxMetricsResponse struct { PodMetrics []*PodSandboxMetrics `protobuf:"bytes,1,rep,name=pod_metrics,json=podMetrics,proto3" json:"pod_metrics,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ListPodSandboxMetricsResponse) Reset() { *m = ListPodSandboxMetricsResponse{} } func (*ListPodSandboxMetricsResponse) ProtoMessage() {} func (*ListPodSandboxMetricsResponse) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{146} } func (m *ListPodSandboxMetricsResponse) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ListPodSandboxMetricsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ListPodSandboxMetricsResponse.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 *ListPodSandboxMetricsResponse) XXX_Merge(src proto.Message) { xxx_messageInfo_ListPodSandboxMetricsResponse.Merge(m, src) } func (m *ListPodSandboxMetricsResponse) XXX_Size() int { return m.Size() } func (m *ListPodSandboxMetricsResponse) XXX_DiscardUnknown() { xxx_messageInfo_ListPodSandboxMetricsResponse.DiscardUnknown(m) } var xxx_messageInfo_ListPodSandboxMetricsResponse proto.InternalMessageInfo func (m *ListPodSandboxMetricsResponse) GetPodMetrics() []*PodSandboxMetrics { if m != nil { return m.PodMetrics } return nil } type PodSandboxMetrics struct { PodSandboxId string `protobuf:"bytes,1,opt,name=pod_sandbox_id,json=podSandboxId,proto3" json:"pod_sandbox_id,omitempty"` Metrics []*Metric `protobuf:"bytes,2,rep,name=metrics,proto3" json:"metrics,omitempty"` ContainerMetrics []*ContainerMetrics `protobuf:"bytes,3,rep,name=container_metrics,json=containerMetrics,proto3" json:"container_metrics,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *PodSandboxMetrics) Reset() { *m = PodSandboxMetrics{} } func (*PodSandboxMetrics) ProtoMessage() {} func (*PodSandboxMetrics) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{147} } func (m *PodSandboxMetrics) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *PodSandboxMetrics) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_PodSandboxMetrics.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 *PodSandboxMetrics) XXX_Merge(src proto.Message) { xxx_messageInfo_PodSandboxMetrics.Merge(m, src) } func (m *PodSandboxMetrics) XXX_Size() int { return m.Size() } func (m *PodSandboxMetrics) XXX_DiscardUnknown() { xxx_messageInfo_PodSandboxMetrics.DiscardUnknown(m) } var xxx_messageInfo_PodSandboxMetrics proto.InternalMessageInfo func (m *PodSandboxMetrics) GetPodSandboxId() string { if m != nil { return m.PodSandboxId } return "" } func (m *PodSandboxMetrics) GetMetrics() []*Metric { if m != nil { return m.Metrics } return nil } func (m *PodSandboxMetrics) GetContainerMetrics() []*ContainerMetrics { if m != nil { return m.ContainerMetrics } return nil } type ContainerMetrics struct { ContainerId string `protobuf:"bytes,1,opt,name=container_id,json=containerId,proto3" json:"container_id,omitempty"` Metrics []*Metric `protobuf:"bytes,2,rep,name=metrics,proto3" json:"metrics,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *ContainerMetrics) Reset() { *m = ContainerMetrics{} } func (*ContainerMetrics) ProtoMessage() {} func (*ContainerMetrics) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{148} } func (m *ContainerMetrics) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *ContainerMetrics) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_ContainerMetrics.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 *ContainerMetrics) XXX_Merge(src proto.Message) { xxx_messageInfo_ContainerMetrics.Merge(m, src) } func (m *ContainerMetrics) XXX_Size() int { return m.Size() } func (m *ContainerMetrics) XXX_DiscardUnknown() { xxx_messageInfo_ContainerMetrics.DiscardUnknown(m) } var xxx_messageInfo_ContainerMetrics proto.InternalMessageInfo func (m *ContainerMetrics) GetContainerId() string { if m != nil { return m.ContainerId } return "" } func (m *ContainerMetrics) GetMetrics() []*Metric { if m != nil { return m.Metrics } return nil } type Metric struct { // Name must match a name previously returned in a MetricDescriptors call, // otherwise, it will be ignored. Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"` // Timestamp should be 0 if the metric was gathered live. // If it was cached, the Timestamp should reflect the time in nanoseconds it was collected. Timestamp int64 `protobuf:"varint,2,opt,name=timestamp,proto3" json:"timestamp,omitempty"` MetricType MetricType `protobuf:"varint,3,opt,name=metric_type,json=metricType,proto3,enum=runtime.v1.MetricType" json:"metric_type,omitempty"` // The corresponding LabelValues to the LabelKeys defined in the MetricDescriptor. // It is the responsibility of the runtime to correctly keep sorted the keys and values. // If the two slices have different length, the behavior is undefined. LabelValues []string `protobuf:"bytes,4,rep,name=label_values,json=labelValues,proto3" json:"label_values,omitempty"` Value *UInt64Value `protobuf:"bytes,5,opt,name=value,proto3" json:"value,omitempty"` XXX_NoUnkeyedLiteral struct{} `json:"-"` XXX_sizecache int32 `json:"-"` } func (m *Metric) Reset() { *m = Metric{} } func (*Metric) ProtoMessage() {} func (*Metric) Descriptor() ([]byte, []int) { return fileDescriptor_00212fb1f9d3bf1c, []int{149} } func (m *Metric) XXX_Unmarshal(b []byte) error { return m.Unmarshal(b) } func (m *Metric) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { if deterministic { return xxx_messageInfo_Metric.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 *Metric) XXX_Merge(src proto.Message) { xxx_messageInfo_Metric.Merge(m, src) } func (m *Metric) XXX_Size() int { return m.Size() } func (m *Metric) XXX_DiscardUnknown() { xxx_messageInfo_Metric.DiscardUnknown(m) } var xxx_messageInfo_Metric proto.InternalMessageInfo func (m *Metric) GetName() string { if m != nil { return m.Name } return "" } func (m *Metric) GetTimestamp() int64 { if m != nil { return m.Timestamp } return 0 } func (m *Metric) GetMetricType() MetricType { if m != nil { return m.MetricType } return MetricType_COUNTER } func (m *Metric) GetLabelValues() []string { if m != nil { return m.LabelValues } return nil } func (m *Metric) GetValue() *UInt64Value { if m != nil { return m.Value } 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{150} } 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{151} } 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{152} } 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") proto.RegisterType((*DNSConfig)(nil), "runtime.v1.DNSConfig") proto.RegisterType((*PortMapping)(nil), "runtime.v1.PortMapping") proto.RegisterType((*Mount)(nil), "runtime.v1.Mount") proto.RegisterType((*IDMapping)(nil), "runtime.v1.IDMapping") proto.RegisterType((*UserNamespace)(nil), "runtime.v1.UserNamespace") proto.RegisterType((*NamespaceOption)(nil), "runtime.v1.NamespaceOption") proto.RegisterType((*Int64Value)(nil), "runtime.v1.Int64Value") proto.RegisterType((*LinuxSandboxSecurityContext)(nil), "runtime.v1.LinuxSandboxSecurityContext") proto.RegisterType((*SecurityProfile)(nil), "runtime.v1.SecurityProfile") proto.RegisterType((*LinuxPodSandboxConfig)(nil), "runtime.v1.LinuxPodSandboxConfig") proto.RegisterMapType((map[string]string)(nil), "runtime.v1.LinuxPodSandboxConfig.SysctlsEntry") proto.RegisterType((*PodSandboxMetadata)(nil), "runtime.v1.PodSandboxMetadata") proto.RegisterType((*PodSandboxConfig)(nil), "runtime.v1.PodSandboxConfig") proto.RegisterMapType((map[string]string)(nil), "runtime.v1.PodSandboxConfig.AnnotationsEntry") proto.RegisterMapType((map[string]string)(nil), "runtime.v1.PodSandboxConfig.LabelsEntry") proto.RegisterType((*RunPodSandboxRequest)(nil), "runtime.v1.RunPodSandboxRequest") proto.RegisterType((*RunPodSandboxResponse)(nil), "runtime.v1.RunPodSandboxResponse") proto.RegisterType((*StopPodSandboxRequest)(nil), "runtime.v1.StopPodSandboxRequest") proto.RegisterType((*StopPodSandboxResponse)(nil), "runtime.v1.StopPodSandboxResponse") proto.RegisterType((*RemovePodSandboxRequest)(nil), "runtime.v1.RemovePodSandboxRequest") proto.RegisterType((*RemovePodSandboxResponse)(nil), "runtime.v1.RemovePodSandboxResponse") proto.RegisterType((*PodSandboxStatusRequest)(nil), "runtime.v1.PodSandboxStatusRequest") proto.RegisterType((*PodIP)(nil), "runtime.v1.PodIP") proto.RegisterType((*PodSandboxNetworkStatus)(nil), "runtime.v1.PodSandboxNetworkStatus") proto.RegisterType((*Namespace)(nil), "runtime.v1.Namespace") proto.RegisterType((*LinuxPodSandboxStatus)(nil), "runtime.v1.LinuxPodSandboxStatus") proto.RegisterType((*PodSandboxStatus)(nil), "runtime.v1.PodSandboxStatus") proto.RegisterMapType((map[string]string)(nil), "runtime.v1.PodSandboxStatus.AnnotationsEntry") proto.RegisterMapType((map[string]string)(nil), "runtime.v1.PodSandboxStatus.LabelsEntry") proto.RegisterType((*PodSandboxStatusResponse)(nil), "runtime.v1.PodSandboxStatusResponse") proto.RegisterMapType((map[string]string)(nil), "runtime.v1.PodSandboxStatusResponse.InfoEntry") proto.RegisterType((*PodSandboxStateValue)(nil), "runtime.v1.PodSandboxStateValue") proto.RegisterType((*PodSandboxFilter)(nil), "runtime.v1.PodSandboxFilter") proto.RegisterMapType((map[string]string)(nil), "runtime.v1.PodSandboxFilter.LabelSelectorEntry") proto.RegisterType((*ListPodSandboxRequest)(nil), "runtime.v1.ListPodSandboxRequest") proto.RegisterType((*PodSandbox)(nil), "runtime.v1.PodSandbox") proto.RegisterMapType((map[string]string)(nil), "runtime.v1.PodSandbox.AnnotationsEntry") proto.RegisterMapType((map[string]string)(nil), "runtime.v1.PodSandbox.LabelsEntry") proto.RegisterType((*ListPodSandboxResponse)(nil), "runtime.v1.ListPodSandboxResponse") proto.RegisterType((*PodSandboxStatsRequest)(nil), "runtime.v1.PodSandboxStatsRequest") proto.RegisterType((*PodSandboxStatsResponse)(nil), "runtime.v1.PodSandboxStatsResponse") proto.RegisterType((*PodSandboxStatsFilter)(nil), "runtime.v1.PodSandboxStatsFilter") proto.RegisterMapType((map[string]string)(nil), "runtime.v1.PodSandboxStatsFilter.LabelSelectorEntry") proto.RegisterType((*ListPodSandboxStatsRequest)(nil), "runtime.v1.ListPodSandboxStatsRequest") proto.RegisterType((*ListPodSandboxStatsResponse)(nil), "runtime.v1.ListPodSandboxStatsResponse") proto.RegisterType((*PodSandboxAttributes)(nil), "runtime.v1.PodSandboxAttributes") proto.RegisterMapType((map[string]string)(nil), "runtime.v1.PodSandboxAttributes.AnnotationsEntry") proto.RegisterMapType((map[string]string)(nil), "runtime.v1.PodSandboxAttributes.LabelsEntry") proto.RegisterType((*PodSandboxStats)(nil), "runtime.v1.PodSandboxStats") proto.RegisterType((*LinuxPodSandboxStats)(nil), "runtime.v1.LinuxPodSandboxStats") proto.RegisterType((*WindowsPodSandboxStats)(nil), "runtime.v1.WindowsPodSandboxStats") proto.RegisterType((*NetworkUsage)(nil), "runtime.v1.NetworkUsage") proto.RegisterType((*WindowsNetworkUsage)(nil), "runtime.v1.WindowsNetworkUsage") proto.RegisterType((*NetworkInterfaceUsage)(nil), "runtime.v1.NetworkInterfaceUsage") proto.RegisterType((*WindowsNetworkInterfaceUsage)(nil), "runtime.v1.WindowsNetworkInterfaceUsage") proto.RegisterType((*ProcessUsage)(nil), "runtime.v1.ProcessUsage") proto.RegisterType((*WindowsProcessUsage)(nil), "runtime.v1.WindowsProcessUsage") proto.RegisterType((*ImageSpec)(nil), "runtime.v1.ImageSpec") proto.RegisterMapType((map[string]string)(nil), "runtime.v1.ImageSpec.AnnotationsEntry") proto.RegisterType((*KeyValue)(nil), "runtime.v1.KeyValue") proto.RegisterType((*LinuxContainerResources)(nil), "runtime.v1.LinuxContainerResources") proto.RegisterMapType((map[string]string)(nil), "runtime.v1.LinuxContainerResources.UnifiedEntry") proto.RegisterType((*HugepageLimit)(nil), "runtime.v1.HugepageLimit") proto.RegisterType((*SELinuxOption)(nil), "runtime.v1.SELinuxOption") 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") proto.RegisterType((*WindowsContainerSecurityContext)(nil), "runtime.v1.WindowsContainerSecurityContext") proto.RegisterType((*WindowsContainerConfig)(nil), "runtime.v1.WindowsContainerConfig") proto.RegisterType((*WindowsContainerResources)(nil), "runtime.v1.WindowsContainerResources") proto.RegisterType((*WindowsCpuGroupAffinity)(nil), "runtime.v1.WindowsCpuGroupAffinity") proto.RegisterType((*ContainerMetadata)(nil), "runtime.v1.ContainerMetadata") proto.RegisterType((*Device)(nil), "runtime.v1.Device") proto.RegisterType((*CDIDevice)(nil), "runtime.v1.CDIDevice") proto.RegisterType((*ContainerConfig)(nil), "runtime.v1.ContainerConfig") proto.RegisterMapType((map[string]string)(nil), "runtime.v1.ContainerConfig.AnnotationsEntry") proto.RegisterMapType((map[string]string)(nil), "runtime.v1.ContainerConfig.LabelsEntry") proto.RegisterType((*CreateContainerRequest)(nil), "runtime.v1.CreateContainerRequest") proto.RegisterType((*CreateContainerResponse)(nil), "runtime.v1.CreateContainerResponse") proto.RegisterType((*StartContainerRequest)(nil), "runtime.v1.StartContainerRequest") proto.RegisterType((*StartContainerResponse)(nil), "runtime.v1.StartContainerResponse") proto.RegisterType((*StopContainerRequest)(nil), "runtime.v1.StopContainerRequest") proto.RegisterType((*StopContainerResponse)(nil), "runtime.v1.StopContainerResponse") proto.RegisterType((*RemoveContainerRequest)(nil), "runtime.v1.RemoveContainerRequest") proto.RegisterType((*RemoveContainerResponse)(nil), "runtime.v1.RemoveContainerResponse") proto.RegisterType((*ContainerStateValue)(nil), "runtime.v1.ContainerStateValue") proto.RegisterType((*ContainerFilter)(nil), "runtime.v1.ContainerFilter") proto.RegisterMapType((map[string]string)(nil), "runtime.v1.ContainerFilter.LabelSelectorEntry") proto.RegisterType((*ListContainersRequest)(nil), "runtime.v1.ListContainersRequest") proto.RegisterType((*Container)(nil), "runtime.v1.Container") proto.RegisterMapType((map[string]string)(nil), "runtime.v1.Container.AnnotationsEntry") proto.RegisterMapType((map[string]string)(nil), "runtime.v1.Container.LabelsEntry") proto.RegisterType((*ListContainersResponse)(nil), "runtime.v1.ListContainersResponse") proto.RegisterType((*ContainerStatusRequest)(nil), "runtime.v1.ContainerStatusRequest") proto.RegisterType((*ContainerStatus)(nil), "runtime.v1.ContainerStatus") proto.RegisterMapType((map[string]string)(nil), "runtime.v1.ContainerStatus.AnnotationsEntry") proto.RegisterMapType((map[string]string)(nil), "runtime.v1.ContainerStatus.LabelsEntry") 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") proto.RegisterType((*ExecSyncRequest)(nil), "runtime.v1.ExecSyncRequest") proto.RegisterType((*ExecSyncResponse)(nil), "runtime.v1.ExecSyncResponse") proto.RegisterType((*ExecRequest)(nil), "runtime.v1.ExecRequest") proto.RegisterType((*ExecResponse)(nil), "runtime.v1.ExecResponse") proto.RegisterType((*AttachRequest)(nil), "runtime.v1.AttachRequest") proto.RegisterType((*AttachResponse)(nil), "runtime.v1.AttachResponse") proto.RegisterType((*PortForwardRequest)(nil), "runtime.v1.PortForwardRequest") proto.RegisterType((*PortForwardResponse)(nil), "runtime.v1.PortForwardResponse") proto.RegisterType((*ImageFilter)(nil), "runtime.v1.ImageFilter") proto.RegisterType((*ListImagesRequest)(nil), "runtime.v1.ListImagesRequest") proto.RegisterType((*Image)(nil), "runtime.v1.Image") proto.RegisterType((*ListImagesResponse)(nil), "runtime.v1.ListImagesResponse") proto.RegisterType((*ImageStatusRequest)(nil), "runtime.v1.ImageStatusRequest") proto.RegisterType((*ImageStatusResponse)(nil), "runtime.v1.ImageStatusResponse") proto.RegisterMapType((map[string]string)(nil), "runtime.v1.ImageStatusResponse.InfoEntry") proto.RegisterType((*AuthConfig)(nil), "runtime.v1.AuthConfig") proto.RegisterType((*PullImageRequest)(nil), "runtime.v1.PullImageRequest") proto.RegisterType((*PullImageResponse)(nil), "runtime.v1.PullImageResponse") proto.RegisterType((*RemoveImageRequest)(nil), "runtime.v1.RemoveImageRequest") proto.RegisterType((*RemoveImageResponse)(nil), "runtime.v1.RemoveImageResponse") proto.RegisterType((*NetworkConfig)(nil), "runtime.v1.NetworkConfig") proto.RegisterType((*RuntimeConfig)(nil), "runtime.v1.RuntimeConfig") proto.RegisterType((*UpdateRuntimeConfigRequest)(nil), "runtime.v1.UpdateRuntimeConfigRequest") proto.RegisterType((*UpdateRuntimeConfigResponse)(nil), "runtime.v1.UpdateRuntimeConfigResponse") 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") proto.RegisterType((*UInt64Value)(nil), "runtime.v1.UInt64Value") proto.RegisterType((*FilesystemIdentifier)(nil), "runtime.v1.FilesystemIdentifier") proto.RegisterType((*FilesystemUsage)(nil), "runtime.v1.FilesystemUsage") proto.RegisterType((*WindowsFilesystemUsage)(nil), "runtime.v1.WindowsFilesystemUsage") proto.RegisterType((*ImageFsInfoResponse)(nil), "runtime.v1.ImageFsInfoResponse") proto.RegisterType((*ContainerStatsRequest)(nil), "runtime.v1.ContainerStatsRequest") proto.RegisterType((*ContainerStatsResponse)(nil), "runtime.v1.ContainerStatsResponse") proto.RegisterType((*ListContainerStatsRequest)(nil), "runtime.v1.ListContainerStatsRequest") proto.RegisterType((*ContainerStatsFilter)(nil), "runtime.v1.ContainerStatsFilter") proto.RegisterMapType((map[string]string)(nil), "runtime.v1.ContainerStatsFilter.LabelSelectorEntry") proto.RegisterType((*ListContainerStatsResponse)(nil), "runtime.v1.ListContainerStatsResponse") proto.RegisterType((*ContainerAttributes)(nil), "runtime.v1.ContainerAttributes") proto.RegisterMapType((map[string]string)(nil), "runtime.v1.ContainerAttributes.AnnotationsEntry") proto.RegisterMapType((map[string]string)(nil), "runtime.v1.ContainerAttributes.LabelsEntry") proto.RegisterType((*ContainerStats)(nil), "runtime.v1.ContainerStats") proto.RegisterType((*WindowsContainerStats)(nil), "runtime.v1.WindowsContainerStats") 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") proto.RegisterType((*CheckpointContainerRequest)(nil), "runtime.v1.CheckpointContainerRequest") proto.RegisterType((*CheckpointContainerResponse)(nil), "runtime.v1.CheckpointContainerResponse") proto.RegisterType((*GetEventsRequest)(nil), "runtime.v1.GetEventsRequest") proto.RegisterType((*ContainerEventResponse)(nil), "runtime.v1.ContainerEventResponse") proto.RegisterType((*ListMetricDescriptorsRequest)(nil), "runtime.v1.ListMetricDescriptorsRequest") proto.RegisterType((*ListMetricDescriptorsResponse)(nil), "runtime.v1.ListMetricDescriptorsResponse") proto.RegisterType((*MetricDescriptor)(nil), "runtime.v1.MetricDescriptor") proto.RegisterType((*ListPodSandboxMetricsRequest)(nil), "runtime.v1.ListPodSandboxMetricsRequest") proto.RegisterType((*ListPodSandboxMetricsResponse)(nil), "runtime.v1.ListPodSandboxMetricsResponse") 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{ // 7180 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, 0xd2, 0xac, 0x45, 0x72, 0xdc, 0x43, 0xae, 0xbd, 0xeb, 0x0b, 0xf7, 0x6d, 0x4d, 0x17, 0x87, 0xbd, 0x9a, 0xe9, 0x6e, 0x77, 0xf7, 0x48, 0xa2, 0x1f, 0x2e, 0xee, 0xd3, 0xc5, 0x8d, 0x9f, 0x0c, 0x24, 0x46, 0x10, 0x23, 0x88, 0xe1, 0x00, 0xf9, 0x79, 0x4b, 0x62, 0x20, 0x8e, 0x83, 0x04, 0x08, 0x10, 0x24, 0x86, 0x13, 0x20, 0x40, 0x1e, 0x12, 0xc0, 0x6f, 0xb1, 0x37, 0x01, 0x02, 0xe4, 0xd9, 0x0f, 0x79, 0x8a, 0x83, 0xfa, 0xeb, 0xee, 0xea, 0x9f, 0x99, 0x21, 0x77, 0xb3, 0xbb, 0x7e, 0xe2, 0x74, 0xd5, 0x39, 0xa7, 0xaa, 0x4e, 0x9d, 0x3a, 0x75, 0xaa, 0xea, 0xab, 0x22, 0x54, 0x0c, 0xd7, 0xba, 0xec, 0x7a, 0x4e, 0xe0, 0x20, 0xf0, 0x06, 0x76, 0x60, 0xf5, 0xf1, 0xe5, 0x27, 0xaf, 0xd6, 0x2f, 0x75, 0xad, 0x60, 0x7f, 0xf0, 0xe8, 0x72, 0xc7, 0xe9, 0x5f, 0xe9, 0x3a, 0x5d, 0xe7, 0x0a, 0x25, 0x79, 0x34, 0xd8, 0xa3, 0x5f, 0xf4, 0x83, 0xfe, 0x62, 0xac, 0xea, 0x45, 0x98, 0x7b, 0x1f, 0x7b, 0xbe, 0xe5, 0xd8, 0x1a, 0xfe, 0xc6, 0x00, 0xfb, 0x01, 0x5a, 0x81, 0xe9, 0x27, 0x2c, 0x65, 0x45, 0x39, 0xab, 0x9c, 0xaf, 0x68, 0xe2, 0x53, 0xfd, 0x03, 0x05, 0xe6, 0x43, 0x62, 0xdf, 0x75, 0x6c, 0x1f, 0xe7, 0x53, 0xa3, 0x73, 0x30, 0xcb, 0xab, 0xa5, 0xdb, 0x46, 0x1f, 0xaf, 0x14, 0x68, 0xf6, 0x0c, 0x4f, 0xdb, 0x32, 0xfa, 0x18, 0xbd, 0x04, 0xf3, 0x82, 0x44, 0x08, 0x29, 0x52, 0xaa, 0x39, 0x9e, 0xcc, 0x4b, 0x43, 0x97, 0xe1, 0x98, 0x20, 0x34, 0x5c, 0x2b, 0x24, 0x2e, 0x51, 0xe2, 0x05, 0x9e, 0xd5, 0x70, 0x2d, 0x4e, 0xaf, 0x7e, 0x0d, 0x2a, 0xeb, 0x5b, 0xed, 0x35, 0xc7, 0xde, 0xb3, 0xba, 0xa4, 0x8a, 0x3e, 0xf6, 0x08, 0xcf, 0x8a, 0x72, 0xb6, 0x48, 0xaa, 0xc8, 0x3f, 0x51, 0x1d, 0xca, 0x3e, 0x36, 0xbc, 0xce, 0x3e, 0xf6, 0x57, 0x0a, 0x34, 0x2b, 0xfc, 0x26, 0x5c, 0x8e, 0x1b, 0x58, 0x8e, 0xed, 0xaf, 0x14, 0x19, 0x17, 0xff, 0x54, 0x7f, 0x5b, 0x81, 0x99, 0x96, 0xe3, 0x05, 0x9b, 0x86, 0xeb, 0x5a, 0x76, 0x17, 0x5d, 0x85, 0x32, 0xd5, 0x65, 0xc7, 0xe9, 0x51, 0x1d, 0xcc, 0x5d, 0x5b, 0xbc, 0x1c, 0x75, 0xc8, 0xe5, 0x16, 0xcf, 0xd3, 0x42, 0x2a, 0xf4, 0x02, 0xcc, 0x75, 0x1c, 0x3b, 0x30, 0x2c, 0x1b, 0x7b, 0xba, 0xeb, 0x78, 0x01, 0x55, 0xce, 0xa4, 0x56, 0x0d, 0x53, 0x89, 0x7c, 0x74, 0x12, 0x2a, 0xfb, 0x8e, 0x1f, 0x30, 0x8a, 0x22, 0xa5, 0x28, 0x93, 0x04, 0x9a, 0xb9, 0x0c, 0xd3, 0x34, 0xd3, 0x72, 0xb9, 0x1a, 0xa6, 0xc8, 0x67, 0xd3, 0x55, 0xbf, 0x57, 0x84, 0xc9, 0x4d, 0x67, 0x60, 0x07, 0x89, 0x62, 0x8c, 0x60, 0x9f, 0x77, 0x51, 0xac, 0x18, 0x23, 0xd8, 0x8f, 0x8a, 0x21, 0x14, 0xac, 0x97, 0x58, 0x31, 0x24, 0xb3, 0x0e, 0x65, 0x0f, 0x1b, 0xa6, 0x63, 0xf7, 0x0e, 0x68, 0x15, 0xca, 0x5a, 0xf8, 0x4d, 0xba, 0xcf, 0xc7, 0x3d, 0xcb, 0x1e, 0x3c, 0xd3, 0x3d, 0xdc, 0x33, 0x1e, 0xe1, 0x1e, 0xad, 0x4a, 0x59, 0x9b, 0xe3, 0xc9, 0x1a, 0x4b, 0x45, 0xef, 0xc0, 0x8c, 0xeb, 0x39, 0xae, 0xd1, 0x35, 0x88, 0x06, 0x57, 0x26, 0xa9, 0x92, 0x4e, 0xc5, 0x95, 0x44, 0x2b, 0xdc, 0x8a, 0x68, 0xb4, 0x38, 0x03, 0x7a, 0x13, 0x66, 0x06, 0x96, 0xc9, 0xf5, 0xed, 0xaf, 0x4c, 0x9d, 0x2d, 0x9e, 0x9f, 0xb9, 0x76, 0x3c, 0xce, 0xdf, 0x5c, 0xe7, 0xb9, 0x5a, 0x9c, 0x92, 0x30, 0x76, 0x63, 0x8c, 0xd3, 0x43, 0x19, 0x63, 0x94, 0xd4, 0xe0, 0x70, 0x67, 0xe0, 0xf9, 0xd6, 0x13, 0xac, 0x93, 0x06, 0xeb, 0x54, 0x03, 0x65, 0xda, 0xbc, 0x85, 0x30, 0x4b, 0xc3, 0x86, 0xb9, 0x4d, 0x54, 0xf1, 0x32, 0x4c, 0x5a, 0x7d, 0xa3, 0x8b, 0x57, 0x2a, 0x67, 0x95, 0x54, 0x11, 0x24, 0xa3, 0xed, 0xe2, 0x8e, 0xc6, 0x68, 0x54, 0x1d, 0x2a, 0x61, 0xb1, 0x51, 0x3f, 0x9a, 0xb4, 0x77, 0xaa, 0xbc, 0x1f, 0x4d, 0x32, 0x7e, 0xa2, 0xde, 0xb3, 0x4c, 0xda, 0x33, 0x55, 0x6d, 0x26, 0x4c, 0x6b, 0x9a, 0x68, 0x09, 0xa6, 0x7a, 0xd8, 0xee, 0x06, 0xfb, 0xb4, 0x6b, 0xaa, 0x1a, 0xff, 0x52, 0x7f, 0x43, 0x81, 0xea, 0xae, 0x8f, 0x3d, 0x32, 0xc8, 0x7c, 0xd7, 0xe8, 0x60, 0x74, 0x09, 0x4a, 0x7d, 0xc7, 0xc4, 0xdc, 0x3e, 0x4f, 0xc4, 0xab, 0x17, 0x12, 0x6d, 0x3a, 0x26, 0xd6, 0x28, 0x19, 0xba, 0x00, 0xa5, 0x81, 0x65, 0xb2, 0x41, 0x91, 0xab, 0x30, 0x4a, 0x42, 0x48, 0xbb, 0x84, 0xb4, 0x38, 0x94, 0x94, 0x90, 0xa8, 0xbf, 0x54, 0x60, 0x3e, 0x2c, 0x6d, 0x9b, 0x8e, 0x26, 0xf4, 0x1a, 0x4c, 0xdb, 0x38, 0x78, 0xea, 0x78, 0x8f, 0x47, 0xd7, 0x4d, 0x50, 0xa2, 0x97, 0xa1, 0xe8, 0x72, 0x8d, 0x0c, 0x65, 0x20, 0x54, 0x84, 0xd8, 0x72, 0x3b, 0x54, 0x43, 0xc3, 0x89, 0x2d, 0xb7, 0x43, 0xc6, 0x42, 0x60, 0x78, 0x5d, 0x4c, 0xfb, 0x83, 0x8d, 0xab, 0x32, 0x4b, 0x68, 0x9a, 0xe8, 0x0e, 0xcc, 0x0d, 0x7c, 0xec, 0xd9, 0xbe, 0x2e, 0x3c, 0xc3, 0x24, 0xed, 0x6d, 0x49, 0xa8, 0xa4, 0x77, 0xad, 0xca, 0x18, 0xb6, 0xb9, 0xeb, 0x50, 0x01, 0x9a, 0x76, 0xf0, 0xc6, 0xf5, 0xf7, 0x8d, 0xde, 0x00, 0xa3, 0x45, 0x98, 0x7c, 0x42, 0x7e, 0xd0, 0x96, 0x17, 0x35, 0xf6, 0xa1, 0x7e, 0x7f, 0x12, 0x4e, 0x3e, 0x24, 0xa3, 0xa7, 0x6d, 0xd8, 0xe6, 0x23, 0xe7, 0x59, 0x9b, 0x18, 0x9b, 0x15, 0x1c, 0xac, 0x39, 0x76, 0x80, 0x9f, 0x05, 0xe8, 0x01, 0x2c, 0xd8, 0x42, 0x7e, 0x58, 0x11, 0x85, 0x56, 0xe4, 0x64, 0x66, 0xeb, 0x58, 0xe1, 0x5a, 0xcd, 0x96, 0x13, 0x7c, 0x74, 0x37, 0x1a, 0xbf, 0x42, 0x4e, 0x21, 0xdd, 0xa0, 0xf6, 0x06, 0xad, 0x0d, 0x97, 0x22, 0x86, 0xb6, 0x90, 0xf1, 0x06, 0x10, 0x8f, 0xae, 0x1b, 0xbe, 0x4e, 0x5a, 0x4a, 0xb5, 0x3c, 0x73, 0x6d, 0x49, 0xb2, 0x82, 0xb0, 0xc1, 0x5a, 0xc5, 0x1b, 0xd8, 0x0d, 0x9f, 0x68, 0x08, 0xdd, 0xa0, 0xb3, 0x03, 0xe1, 0xeb, 0x7a, 0xce, 0xc0, 0xa5, 0x23, 0x2b, 0x9f, 0x11, 0x28, 0xe3, 0x7d, 0x42, 0x49, 0x27, 0x0d, 0xee, 0x81, 0x74, 0xcf, 0x71, 0x82, 0x3d, 0x5f, 0x78, 0x1d, 0x91, 0xac, 0xd1, 0x54, 0x74, 0x05, 0x8e, 0xf9, 0x03, 0xd7, 0xed, 0xe1, 0x3e, 0xb6, 0x03, 0xa3, 0xc7, 0x0a, 0x22, 0x7d, 0x56, 0x3c, 0x5f, 0xd4, 0x50, 0x3c, 0x8b, 0x0a, 0xf6, 0xd1, 0x23, 0xa8, 0x67, 0x30, 0xe8, 0xae, 0xd3, 0xb3, 0x3a, 0x07, 0x2b, 0x33, 0xd4, 0x80, 0x9e, 0x97, 0x54, 0x93, 0x92, 0xd1, 0xa2, 0xb4, 0xda, 0x8a, 0x9f, 0x93, 0x83, 0x56, 0x01, 0x5c, 0xcf, 0x7a, 0x62, 0xf5, 0x70, 0x17, 0x9b, 0x2b, 0x53, 0xb4, 0xe2, 0xb1, 0x14, 0xf4, 0x3a, 0x99, 0xac, 0x3a, 0x1d, 0xa7, 0xef, 0x72, 0x57, 0x22, 0xf5, 0xa9, 0xb0, 0x85, 0x96, 0xe7, 0xec, 0x59, 0x3d, 0xac, 0x09, 0x5a, 0xf4, 0x26, 0x94, 0x0d, 0xd7, 0x35, 0xbc, 0xbe, 0xe3, 0xad, 0xc0, 0x68, 0xbe, 0x90, 0x18, 0x5d, 0x87, 0x45, 0x2e, 0x43, 0x77, 0x59, 0x26, 0x9b, 0x07, 0xa6, 0x89, 0xed, 0xdf, 0x2d, 0xac, 0x28, 0x1a, 0xe2, 0xf9, 0x9c, 0x97, 0xcc, 0x0a, 0xea, 0xdf, 0x28, 0x30, 0x9f, 0x90, 0x89, 0xde, 0x83, 0x59, 0x21, 0x21, 0x38, 0x70, 0x85, 0xab, 0x79, 0x69, 0x48, 0x35, 0x2e, 0xf3, 0xbf, 0x3b, 0x07, 0x2e, 0xa6, 0x0e, 0x5f, 0x7c, 0xa0, 0xe7, 0xa0, 0xda, 0x73, 0x3a, 0x46, 0x8f, 0x7a, 0x46, 0x0f, 0xef, 0xf1, 0x69, 0x69, 0x36, 0x4c, 0xd4, 0xf0, 0x9e, 0x7a, 0x07, 0x66, 0x62, 0x02, 0x10, 0x82, 0x39, 0x8d, 0x15, 0xb5, 0x8e, 0xf7, 0x8c, 0x41, 0x2f, 0xa8, 0x4d, 0xa0, 0x39, 0x80, 0x5d, 0xbb, 0x43, 0xc2, 0x00, 0x1b, 0x9b, 0x35, 0x05, 0x55, 0xa1, 0xf2, 0x50, 0x88, 0xa8, 0x15, 0xd4, 0xef, 0x16, 0xe1, 0x38, 0x35, 0xee, 0x96, 0x63, 0xf2, 0xd1, 0xc6, 0x63, 0x86, 0xe7, 0xa0, 0xda, 0xa1, 0xdd, 0xaf, 0xbb, 0x86, 0x87, 0xed, 0x80, 0xcf, 0x9c, 0xb3, 0x2c, 0xb1, 0x45, 0xd3, 0x90, 0x06, 0x35, 0x9f, 0xb7, 0x48, 0xef, 0xb0, 0xd1, 0xc9, 0x07, 0x90, 0xd4, 0xea, 0x21, 0x83, 0x59, 0x9b, 0xf7, 0x53, 0xa3, 0x7b, 0xda, 0x3f, 0xf0, 0x3b, 0x41, 0x4f, 0x78, 0xd4, 0xcb, 0x29, 0x51, 0xc9, 0xca, 0x5e, 0x6e, 0x33, 0x86, 0x0d, 0x3b, 0xf0, 0x0e, 0x34, 0xc1, 0x8e, 0xde, 0x85, 0xb2, 0xf3, 0x04, 0x7b, 0xfb, 0xd8, 0x60, 0x9e, 0x6c, 0xe6, 0xda, 0x73, 0x29, 0x51, 0x6b, 0x62, 0x32, 0xd1, 0xb0, 0xef, 0x0c, 0xbc, 0x0e, 0xf6, 0xb5, 0x90, 0x09, 0x35, 0xa0, 0xe2, 0x89, 0x64, 0xee, 0xe9, 0xc6, 0x92, 0x10, 0x71, 0xd5, 0x6f, 0xc1, 0x6c, 0xbc, 0x72, 0xa8, 0x06, 0xc5, 0xc7, 0xf8, 0x80, 0x2b, 0x93, 0xfc, 0x8c, 0x7c, 0x20, 0xeb, 0x61, 0xf6, 0x71, 0xab, 0x70, 0x43, 0x51, 0x3d, 0x40, 0x51, 0x4b, 0x37, 0x71, 0x60, 0x98, 0x46, 0x60, 0x20, 0x04, 0x25, 0x1a, 0x4d, 0x32, 0x11, 0xf4, 0x37, 0x91, 0x3a, 0xe0, 0xd3, 0x41, 0x45, 0x23, 0x3f, 0xd1, 0x29, 0xa8, 0x84, 0xde, 0x8e, 0x87, 0x94, 0x51, 0x02, 0x09, 0xed, 0x8c, 0x20, 0xc0, 0x7d, 0x37, 0xa0, 0x8a, 0xa9, 0x6a, 0xe2, 0x53, 0xfd, 0xb5, 0x49, 0xa8, 0xa5, 0x6c, 0xe1, 0x16, 0x94, 0xfb, 0xbc, 0x78, 0xee, 0x67, 0x57, 0xa5, 0xf8, 0x2e, 0x55, 0x49, 0x2d, 0xa4, 0x27, 0xe1, 0x13, 0xb1, 0xb5, 0x58, 0x00, 0x1c, 0x7e, 0x33, 0x23, 0xef, 0xea, 0xa6, 0xe5, 0xe1, 0x4e, 0xe0, 0x78, 0x07, 0xbc, 0xa2, 0xb3, 0x3d, 0xa7, 0xbb, 0x2e, 0xd2, 0xd0, 0x75, 0x00, 0xd3, 0xf6, 0x75, 0x6a, 0xc3, 0x5d, 0xde, 0x8f, 0xd2, 0x24, 0x1b, 0xc6, 0xb9, 0x5a, 0xc5, 0xb4, 0x7d, 0x5e, 0xe5, 0xdb, 0x50, 0x25, 0x41, 0xa3, 0xde, 0x17, 0x91, 0xcf, 0x24, 0xb5, 0xa5, 0x65, 0xb9, 0xde, 0x61, 0x08, 0xab, 0xcd, 0xba, 0xd1, 0x87, 0x8f, 0xee, 0xc0, 0x14, 0x8d, 0xdb, 0x44, 0xa4, 0x75, 0x3e, 0xbb, 0xb9, 0xdc, 0xfa, 0x1e, 0x52, 0x52, 0x66, 0x7c, 0x9c, 0x0f, 0x6d, 0xc3, 0x8c, 0x61, 0xdb, 0x4e, 0x60, 0xb0, 0x59, 0x85, 0xc5, 0x5d, 0x97, 0x86, 0x8a, 0x69, 0x44, 0xf4, 0x4c, 0x56, 0x5c, 0x02, 0x7a, 0x13, 0x26, 0xe9, 0xb4, 0xc3, 0xe7, 0x89, 0x73, 0x23, 0x07, 0x85, 0xc6, 0xe8, 0xd1, 0xdb, 0x30, 0xfd, 0xd4, 0xb2, 0x4d, 0xe7, 0xa9, 0xcf, 0xfd, 0xa9, 0x64, 0xc2, 0x5f, 0x61, 0x59, 0x29, 0x66, 0xc1, 0x53, 0xbf, 0x09, 0x33, 0xb1, 0xf6, 0x1d, 0xc6, 0x7e, 0xeb, 0xef, 0x40, 0x2d, 0xd9, 0xa6, 0x43, 0xd9, 0xff, 0x00, 0x16, 0xb5, 0x81, 0x1d, 0x55, 0x4d, 0xac, 0xcf, 0xae, 0xc3, 0x14, 0xb7, 0x06, 0x66, 0x8c, 0xa7, 0x86, 0xa9, 0x55, 0xe3, 0xb4, 0xf1, 0xa5, 0xd6, 0xbe, 0x61, 0x9b, 0x3d, 0xec, 0xf1, 0x12, 0xc5, 0x52, 0xeb, 0x01, 0x4b, 0x55, 0xdf, 0x86, 0xe3, 0x89, 0x62, 0xf9, 0x4a, 0xef, 0x79, 0x98, 0x73, 0x1d, 0x53, 0xf7, 0x59, 0xb2, 0x88, 0x57, 0x2b, 0xc4, 0x76, 0x04, 0x6d, 0xd3, 0x24, 0xec, 0xed, 0xc0, 0x71, 0xd3, 0xd5, 0x1e, 0x8f, 0x7d, 0x05, 0x96, 0x92, 0xec, 0xac, 0x78, 0xf5, 0x5d, 0x58, 0xd6, 0x70, 0xdf, 0x79, 0x82, 0x8f, 0x2a, 0xba, 0x0e, 0x2b, 0x69, 0x01, 0x5c, 0xf8, 0x07, 0xb0, 0x1c, 0xa5, 0xb6, 0x03, 0x23, 0x18, 0xf8, 0x87, 0x12, 0xce, 0x97, 0xc1, 0x8f, 0x1c, 0x9f, 0x75, 0x64, 0x59, 0x13, 0x9f, 0xea, 0x32, 0x4c, 0xb6, 0x1c, 0xb3, 0xd9, 0x42, 0x73, 0x50, 0xb0, 0x5c, 0xce, 0x5c, 0xb0, 0x5c, 0xb5, 0x13, 0x2f, 0x73, 0x8b, 0x45, 0xb6, 0xac, 0xe8, 0x24, 0x29, 0xba, 0x01, 0x73, 0x86, 0x69, 0x5a, 0xc4, 0x90, 0x8c, 0x9e, 0x6e, 0xb9, 0x22, 0x30, 0x5f, 0x48, 0x74, 0x7d, 0xb3, 0xa5, 0x55, 0x23, 0xc2, 0xa6, 0xeb, 0xab, 0x77, 0xa1, 0x12, 0x2d, 0x02, 0x5e, 0x8f, 0x96, 0xb4, 0x85, 0xd1, 0xf1, 0x62, 0xb8, 0xde, 0xdd, 0x4a, 0x4d, 0x92, 0xbc, 0x9a, 0xaf, 0x03, 0x84, 0x4e, 0x55, 0x84, 0xa0, 0xc7, 0x33, 0x45, 0x6a, 0x31, 0x42, 0xf5, 0x5f, 0x4a, 0x71, 0x27, 0x1b, 0x6b, 0xb2, 0x19, 0x36, 0xd9, 0x94, 0x9c, 0x6e, 0xe1, 0x90, 0x4e, 0xf7, 0x55, 0x98, 0xf4, 0x03, 0x23, 0xc0, 0x3c, 0xe6, 0x3f, 0x99, 0xcd, 0x48, 0x0a, 0xc6, 0x1a, 0xa3, 0x44, 0xa7, 0x01, 0x3a, 0x1e, 0x36, 0x02, 0x6c, 0xea, 0x06, 0x9b, 0x15, 0x8a, 0x5a, 0x85, 0xa7, 0x34, 0x02, 0xe2, 0x45, 0xc4, 0x2a, 0x25, 0x63, 0x22, 0xcc, 0xe9, 0xc6, 0x68, 0xbd, 0x12, 0x7a, 0xaf, 0xa9, 0x91, 0xde, 0x8b, 0xb3, 0x72, 0xef, 0x15, 0x79, 0xe2, 0xe9, 0x61, 0x9e, 0x98, 0x31, 0x8d, 0xe3, 0x89, 0xcb, 0xc3, 0x3c, 0x31, 0x17, 0x33, 0xdc, 0x13, 0x67, 0x38, 0x92, 0x4a, 0x96, 0x23, 0xf9, 0x3c, 0x5d, 0xe7, 0x9f, 0x17, 0x60, 0x25, 0x3d, 0x9e, 0xb9, 0x1f, 0xbb, 0x0e, 0x53, 0x3e, 0x4d, 0x19, 0xee, 0x3f, 0x39, 0x17, 0xa7, 0x45, 0x77, 0xa1, 0x64, 0xd9, 0x7b, 0x0e, 0x1f, 0x78, 0x97, 0x87, 0xf2, 0xf0, 0x92, 0x2e, 0x37, 0xed, 0x3d, 0x87, 0x69, 0x90, 0xf2, 0xa2, 0x87, 0x70, 0x2c, 0x5c, 0xbd, 0xfb, 0x3a, 0x13, 0x8c, 0x45, 0x9c, 0x27, 0x59, 0x69, 0x18, 0x55, 0x71, 0x89, 0x28, 0xe2, 0x6b, 0x73, 0x36, 0x12, 0xe3, 0x10, 0x72, 0x3f, 0x30, 0xfa, 0xae, 0xb0, 0xd8, 0x30, 0xa1, 0xfe, 0x26, 0x54, 0xc2, 0xe2, 0x0f, 0xa5, 0xbb, 0x26, 0x2c, 0x26, 0xc6, 0x08, 0x5b, 0xac, 0x86, 0x83, 0x4a, 0x19, 0x77, 0x50, 0xa9, 0xbf, 0x50, 0xe2, 0x03, 0xfd, 0x9e, 0xd5, 0x0b, 0xb0, 0x97, 0x1a, 0xe8, 0x6f, 0x08, 0xb9, 0x6c, 0x94, 0x9f, 0x1d, 0x22, 0x97, 0xad, 0x05, 0xf9, 0x88, 0x7d, 0x1f, 0xe6, 0xa8, 0x89, 0xeb, 0x3e, 0xee, 0xd1, 0x58, 0x89, 0xeb, 0xf1, 0x4a, 0xb6, 0x00, 0x56, 0x3a, 0x1b, 0x22, 0x6d, 0xce, 0xc1, 0xfa, 0xa6, 0xda, 0x8b, 0xa7, 0xd5, 0xef, 0x00, 0x4a, 0x13, 0x1d, 0x4a, 0x83, 0x9b, 0xc4, 0x5f, 0xfa, 0x41, 0xe6, 0xcc, 0xbd, 0x47, 0xab, 0x31, 0xdc, 0xf2, 0x58, 0x55, 0x35, 0x4e, 0xab, 0xfe, 0x73, 0x11, 0x20, 0xca, 0xfc, 0x82, 0x3b, 0xca, 0x5b, 0xa1, 0xc3, 0x62, 0x11, 0xa7, 0x9a, 0x2d, 0x32, 0xd3, 0x55, 0x35, 0x65, 0x57, 0xc5, 0x62, 0xcf, 0x97, 0x72, 0x04, 0x1c, 0xda, 0x49, 0x4d, 0x7f, 0xd1, 0x9c, 0xd4, 0x3d, 0x58, 0x4a, 0x9a, 0x09, 0xf7, 0x50, 0xaf, 0xc0, 0xa4, 0x15, 0xe0, 0x3e, 0xdb, 0xae, 0x4e, 0x6c, 0x8a, 0xc4, 0xc8, 0x19, 0x91, 0xfa, 0x0e, 0x2c, 0xc9, 0x7d, 0x75, 0xb8, 0xd0, 0x45, 0x7d, 0x98, 0x8c, 0x7d, 0x22, 0x57, 0xc9, 0xed, 0x23, 0x73, 0x7b, 0x29, 0xc9, 0xc3, 0x28, 0xd5, 0x1f, 0x2b, 0x70, 0x3c, 0x91, 0x95, 0x33, 0xf0, 0xbf, 0x96, 0x1a, 0xc0, 0xcc, 0xb7, 0x5e, 0x1f, 0x52, 0xca, 0x67, 0x38, 0x8a, 0xbf, 0x02, 0x75, 0xb9, 0x7b, 0x24, 0xd5, 0xde, 0x4c, 0x0c, 0xe5, 0x73, 0x23, 0x2b, 0x1d, 0x8e, 0xe7, 0x16, 0x9c, 0xcc, 0x14, 0x9c, 0xd6, 0x79, 0x71, 0x4c, 0x9d, 0xff, 0x67, 0x21, 0xee, 0xb3, 0x1b, 0x41, 0xe0, 0x59, 0x8f, 0x06, 0x01, 0xfe, 0x74, 0x83, 0xaa, 0xf5, 0x70, 0x64, 0x33, 0x3f, 0xfb, 0x4a, 0x36, 0x67, 0x54, 0x7a, 0xe6, 0x18, 0x6f, 0xcb, 0x63, 0xbc, 0x44, 0x45, 0xbd, 0x3a, 0x52, 0xd4, 0xd0, 0xd1, 0xfe, 0x79, 0x0e, 0xe2, 0xbf, 0x53, 0x60, 0x3e, 0xd1, 0x2b, 0xe8, 0x0e, 0x80, 0x11, 0x56, 0x9d, 0xdb, 0xc7, 0xd9, 0x51, 0x4d, 0xd4, 0x62, 0x3c, 0x64, 0x4e, 0x64, 0xf1, 0x62, 0xc6, 0x9c, 0x98, 0x11, 0x2f, 0x86, 0xe1, 0xe2, 0xed, 0x68, 0xb1, 0xcb, 0x36, 0x62, 0xd5, 0xa1, 0x8b, 0x5d, 0xc6, 0x2b, 0x58, 0xd4, 0x5f, 0x2f, 0xc0, 0x62, 0x96, 0x74, 0xf4, 0x22, 0x14, 0x3b, 0xee, 0x80, 0xb7, 0x44, 0x3a, 0xdb, 0x5a, 0x73, 0x07, 0xbb, 0xbe, 0xd1, 0xc5, 0x1a, 0x21, 0x40, 0x57, 0x60, 0xaa, 0x8f, 0xfb, 0x8e, 0x77, 0xc0, 0xeb, 0x2d, 0x6d, 0x37, 0x6c, 0xd2, 0x1c, 0x46, 0xcd, 0xc9, 0xd0, 0xb5, 0x28, 0xac, 0x66, 0xf5, 0x5d, 0x91, 0x56, 0x0f, 0x2c, 0x8b, 0xb1, 0x84, 0xb1, 0xf4, 0x35, 0x98, 0x76, 0x3d, 0xa7, 0x83, 0x7d, 0x9f, 0xef, 0x86, 0xac, 0x24, 0x0e, 0xdb, 0x48, 0x16, 0xe7, 0xe1, 0x84, 0xe8, 0x16, 0x40, 0x14, 0x40, 0xf1, 0x99, 0xa9, 0x9e, 0x1b, 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, 0x29, 0x30, 0x1b, 0xaf, 0x97, 0x1c, 0xb2, 0x2a, 0x89, 0x90, 0x15, 0x6d, 0xc1, 0x82, 0xc9, 0x76, 0x6e, 0x75, 0xcb, 0x0e, 0xb0, 0xb7, 0x67, 0x74, 0x44, 0x54, 0x78, 0x2e, 0xc3, 0x2e, 0x9a, 0x82, 0x86, 0x55, 0xbc, 0xc6, 0x79, 0xc3, 0x64, 0xd2, 0x82, 0x50, 0x8e, 0xf0, 0x5a, 0x63, 0x08, 0x8a, 0x31, 0xa9, 0xff, 0xa4, 0xc0, 0xb1, 0x0c, 0x05, 0x8f, 0x68, 0xc8, 0x6e, 0x7e, 0x43, 0xce, 0xe7, 0x77, 0xdd, 0xc8, 0xf6, 0x3c, 0xc8, 0x68, 0xcf, 0xf8, 0xf2, 0xe2, 0xcd, 0xfa, 0xa5, 0x02, 0xc7, 0x33, 0xa9, 0x32, 0xb7, 0x57, 0xaf, 0x41, 0xd9, 0x7b, 0xa6, 0x3f, 0x3a, 0x08, 0xb0, 0x9f, 0x35, 0xb0, 0x77, 0x63, 0xe7, 0x34, 0xd3, 0xde, 0xb3, 0xbb, 0x84, 0x0e, 0x5d, 0x87, 0x8a, 0xf7, 0x4c, 0xc7, 0x9e, 0xe7, 0x78, 0xc2, 0x17, 0xe5, 0x32, 0x95, 0xbd, 0x67, 0x1b, 0x94, 0x90, 0x94, 0x14, 0x88, 0x92, 0x4a, 0x23, 0x4a, 0x0a, 0xa2, 0x92, 0x82, 0xb0, 0xa4, 0xc9, 0x11, 0x25, 0x05, 0xbc, 0x24, 0xf5, 0x0f, 0x0b, 0x70, 0x6a, 0x98, 0xba, 0x3e, 0x35, 0x45, 0x6c, 0x00, 0xf2, 0x9e, 0xe9, 0xae, 0xd1, 0x79, 0x8c, 0x03, 0x5f, 0x37, 0x3d, 0xc7, 0x75, 0xb1, 0x39, 0x4a, 0x23, 0x35, 0xef, 0x59, 0x8b, 0x71, 0xac, 0x33, 0x86, 0x23, 0x69, 0x66, 0x03, 0x50, 0x90, 0x2e, 0x7a, 0x84, 0x8a, 0x6a, 0x41, 0xa2, 0x68, 0xf5, 0x23, 0x98, 0x8d, 0x7b, 0x88, 0x11, 0xb6, 0x7f, 0x1b, 0xaa, 0xdc, 0x83, 0xe8, 0x1d, 0x67, 0x60, 0x07, 0xa3, 0x14, 0x35, 0xcb, 0xa9, 0xd7, 0x08, 0xb1, 0xfa, 0x8d, 0x70, 0xb8, 0x7d, 0x66, 0x45, 0xfe, 0xbf, 0x02, 0x54, 0xc2, 0x13, 0x7a, 0x32, 0xd3, 0xb3, 0x73, 0x7c, 0xd6, 0xef, 0xec, 0x03, 0x3d, 0x90, 0xa3, 0x16, 0x16, 0xa7, 0xbe, 0x98, 0x79, 0xc6, 0x3f, 0x62, 0x61, 0x72, 0x15, 0x16, 0x07, 0x3e, 0xf6, 0x74, 0xdf, 0xc5, 0x1d, 0x6b, 0xcf, 0xc2, 0xa6, 0xce, 0x8a, 0x43, 0xb4, 0x38, 0x44, 0xf2, 0xda, 0x22, 0x8b, 0xca, 0xcc, 0x5a, 0xca, 0x1c, 0xcb, 0x5c, 0xca, 0x7c, 0xd2, 0x50, 0xe6, 0x1a, 0x94, 0xbf, 0x84, 0x0f, 0xd8, 0x62, 0x7f, 0x4c, 0x3e, 0xf5, 0x3b, 0x25, 0x58, 0xce, 0x39, 0x06, 0xa2, 0x2b, 0x45, 0x77, 0xa0, 0xbb, 0xd8, 0xb3, 0x1c, 0x53, 0xf4, 0x5a, 0xc7, 0x1d, 0xb4, 0x68, 0x02, 0x3a, 0x09, 0xe4, 0x43, 0xff, 0xc6, 0xc0, 0xe1, 0xc1, 0x68, 0x51, 0x2b, 0x77, 0xdc, 0xc1, 0x97, 0xc9, 0xb7, 0xe0, 0xf5, 0xf7, 0x0d, 0x0f, 0x33, 0xff, 0xc1, 0x78, 0xdb, 0x34, 0x01, 0xbd, 0x0a, 0xc7, 0xd9, 0xdc, 0xa8, 0xf7, 0xac, 0xbe, 0x45, 0xbc, 0x6c, 0x6c, 0x68, 0x14, 0x35, 0xc4, 0x32, 0x1f, 0x92, 0xbc, 0xa6, 0xcd, 0x06, 0x83, 0x0a, 0x55, 0xc7, 0xe9, 0xeb, 0x7e, 0xc7, 0xf1, 0xb0, 0x6e, 0x98, 0x1f, 0xd1, 0x71, 0x50, 0xd4, 0x66, 0x1c, 0xa7, 0xdf, 0x26, 0x69, 0x0d, 0xf3, 0x23, 0x74, 0x06, 0x66, 0x3a, 0xee, 0xc0, 0xc7, 0x81, 0x4e, 0xfe, 0xd0, 0xcd, 0xba, 0x8a, 0x06, 0x2c, 0x69, 0xcd, 0x1d, 0xf8, 0x31, 0x82, 0x3e, 0x59, 0x9e, 0x4d, 0xc7, 0x09, 0x36, 0x71, 0x9f, 0x9e, 0xa8, 0xef, 0x0f, 0xba, 0xd8, 0x35, 0xba, 0x98, 0x55, 0x4d, 0xec, 0xb8, 0x49, 0x27, 0xea, 0x0f, 0x38, 0x09, 0xad, 0xa0, 0x36, 0xb7, 0x1f, 0xff, 0xf4, 0xd1, 0x7b, 0x30, 0x3d, 0xb0, 0xa9, 0x01, 0xac, 0x54, 0x28, 0xef, 0xd5, 0x31, 0x0e, 0xdd, 0x2e, 0xef, 0x32, 0x16, 0x7e, 0x06, 0xc8, 0x05, 0xa0, 0x5b, 0x50, 0xe7, 0x8a, 0xf2, 0x9f, 0x1a, 0x6e, 0x52, 0x5b, 0x40, 0x55, 0xb0, 0xc4, 0x28, 0xda, 0x4f, 0x0d, 0x37, 0xae, 0xb1, 0xfa, 0x2d, 0x98, 0x8d, 0x0b, 0x3d, 0x94, 0x2d, 0xdd, 0x85, 0xaa, 0xd4, 0x48, 0xd2, 0xdb, 0x54, 0x29, 0xbe, 0xf5, 0x4d, 0x31, 0xb6, 0xca, 0x24, 0xa1, 0x6d, 0x7d, 0x93, 0xe2, 0x20, 0x68, 0xcd, 0xa8, 0x9c, 0x92, 0xc6, 0x3e, 0x54, 0x03, 0xaa, 0x12, 0xf4, 0x80, 0xb8, 0x64, 0x8a, 0x31, 0xe0, 0x2e, 0x99, 0xfc, 0x26, 0x69, 0x9e, 0xd3, 0x13, 0x35, 0xa0, 0xbf, 0x49, 0x1a, 0x3d, 0x80, 0x66, 0xc7, 0x69, 0xf4, 0x37, 0x2d, 0x02, 0x3f, 0xe1, 0x00, 0xa5, 0x8a, 0xc6, 0x3e, 0xd4, 0xdf, 0x51, 0x00, 0xd6, 0x0c, 0xd7, 0x78, 0x64, 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, 0x38, 0x54, 0x99, 0x96, 0x41, 0xc8, 0x6a, 0x24, 0x43, 0x22, 0xbe, 0x01, 0x2b, 0x44, 0xae, 0xd1, 0x7f, 0x64, 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, 0x29, 0x21, 0x4d, 0x4a, 0x9f, 0x10, 0x69, 0x32, 0x79, 0x54, 0xa4, 0xc9, 0xec, 0xd8, 0x48, 0x93, 0x17, 0xa9, 0xeb, 0x15, 0x25, 0xd2, 0x70, 0x80, 0xf9, 0x84, 0x6a, 0x28, 0xdd, 0x16, 0x30, 0xc6, 0x04, 0x22, 0x65, 0xfa, 0x30, 0x88, 0x94, 0xf2, 0x11, 0x11, 0x29, 0x0b, 0x9f, 0x0a, 0x22, 0xe5, 0x2c, 0xcc, 0xda, 0x8e, 0x6e, 0xe3, 0xa7, 0x3a, 0xe9, 0x7a, 0x9f, 0xe2, 0x5c, 0xca, 0x1a, 0xd8, 0xce, 0x16, 0x7e, 0xda, 0x22, 0x29, 0xe8, 0x1c, 0xcc, 0xf6, 0x0d, 0xff, 0x31, 0x36, 0x29, 0x34, 0xc4, 0x5f, 0xa9, 0x52, 0x9b, 0x9d, 0x61, 0x69, 0x2d, 0x92, 0x84, 0x5e, 0x80, 0xb0, 0xad, 0x9c, 0x68, 0x8e, 0x12, 0x55, 0x45, 0x2a, 0x23, 0x8b, 0xa1, 0x5b, 0xe6, 0x8f, 0x88, 0x6e, 0xa9, 0x1d, 0x06, 0xdd, 0x72, 0x09, 0x6a, 0xe2, 0xb7, 0x80, 0xb7, 0xb0, 0xd3, 0x0a, 0x8a, 0x6c, 0x99, 0x17, 0x79, 0x02, 0xc2, 0x92, 0x07, 0x86, 0x81, 0xa1, 0x60, 0x98, 0x3f, 0x52, 0xf8, 0xba, 0x39, 0x1c, 0xa4, 0xfc, 0x14, 0x5e, 0x02, 0x50, 0x28, 0x47, 0x01, 0x50, 0xa0, 0x9d, 0x5c, 0x88, 0xc9, 0x85, 0x7c, 0x49, 0xa3, 0x40, 0x26, 0xaa, 0x05, 0x48, 0xe6, 0xa0, 0x03, 0x85, 0xc3, 0x28, 0xd8, 0x4c, 0x4d, 0x61, 0x14, 0x35, 0x28, 0x76, 0x39, 0xb0, 0xa2, 0xa8, 0x91, 0x9f, 0x79, 0x16, 0x5c, 0xcc, 0xb3, 0x60, 0x75, 0x33, 0x5c, 0x3d, 0x7f, 0x1a, 0xc8, 0x3f, 0xf5, 0xdf, 0x14, 0x38, 0xcd, 0xe5, 0xe5, 0xc0, 0xe3, 0x32, 0x06, 0xad, 0x92, 0x33, 0x68, 0x3b, 0x1e, 0x36, 0xb1, 0x1d, 0x58, 0x46, 0x8f, 0xc6, 0x63, 0xe2, 0x40, 0x3c, 0x4a, 0xa6, 0x21, 0xe1, 0x39, 0x98, 0x65, 0xf0, 0x58, 0xbe, 0x90, 0x66, 0x28, 0xd8, 0x19, 0x8a, 0x90, 0xe5, 0x6b, 0xe5, 0xed, 0x2c, 0x47, 0x59, 0xca, 0xdd, 0x81, 0x19, 0xe9, 0x2f, 0x55, 0x07, 0x96, 0x73, 0xa0, 0x09, 0x99, 0x16, 0xa1, 0xa4, 0x2d, 0x62, 0xa8, 0x92, 0xd2, 0x16, 0xf1, 0x1d, 0x05, 0xce, 0xa4, 0x16, 0xf4, 0x9f, 0xbf, 0x66, 0xd5, 0x3f, 0x55, 0x42, 0xfb, 0x49, 0x8e, 0xae, 0xb5, 0xf4, 0xe8, 0x7a, 0x61, 0xd8, 0xfe, 0x44, 0xe6, 0xf8, 0x7a, 0x3f, 0x77, 0x7c, 0xbd, 0x3c, 0x74, 0xaf, 0x63, 0x94, 0x3e, 0x7f, 0xbf, 0x00, 0x27, 0x72, 0x2b, 0x90, 0x08, 0x6f, 0x95, 0x64, 0x78, 0xcb, 0x43, 0xe3, 0x68, 0x31, 0xc3, 0x42, 0x63, 0xba, 0x5e, 0xe1, 0x31, 0xa8, 0xde, 0x37, 0x9e, 0x59, 0xfd, 0x41, 0x9f, 0xc7, 0xc6, 0x44, 0xdc, 0x26, 0x4b, 0x39, 0x4a, 0x70, 0x7c, 0x05, 0x16, 0xd9, 0xbc, 0x45, 0xe3, 0xb3, 0x88, 0x83, 0xc5, 0xc8, 0x0b, 0x2c, 0x8f, 0x84, 0x6a, 0x82, 0xe1, 0x01, 0x54, 0x8d, 0xbd, 0x3d, 0xcb, 0xa6, 0x6a, 0x63, 0xb1, 0x72, 0x31, 0x07, 0x5b, 0xb3, 0xe6, 0x0e, 0xa8, 0x2b, 0x68, 0x70, 0x7a, 0x6d, 0x56, 0x70, 0x92, 0x90, 0x5a, 0xfd, 0x72, 0x68, 0xe9, 0x49, 0x42, 0x74, 0x02, 0xca, 0xac, 0xa5, 0x3e, 0xf3, 0x10, 0x25, 0x6d, 0x9a, 0x36, 0xd3, 0x7f, 0x2c, 0x34, 0xc4, 0x26, 0x74, 0x06, 0x8c, 0x26, 0xb4, 0x94, 0x5f, 0x6d, 0xc0, 0x42, 0xa8, 0xf3, 0xa1, 0xb8, 0xb1, 0x18, 0x0e, 0xac, 0x20, 0xe3, 0xc0, 0x6c, 0x98, 0x5a, 0xc7, 0x4f, 0xac, 0x0e, 0xfe, 0x54, 0x30, 0xf4, 0x67, 0x61, 0xc6, 0xc5, 0x5e, 0xdf, 0xf2, 0xfd, 0x30, 0x82, 0xaa, 0x68, 0xf1, 0x24, 0xf5, 0x0c, 0x54, 0xd6, 0xd6, 0x9b, 0xbc, 0xc8, 0x8c, 0xaa, 0xaa, 0xff, 0x3e, 0x05, 0xf3, 0xc9, 0x01, 0x70, 0x33, 0x85, 0x4b, 0x3b, 0x9d, 0xb9, 0xa7, 0x99, 0xb1, 0x99, 0x1f, 0xc2, 0xd5, 0x0b, 0xa3, 0xe1, 0xea, 0x44, 0x4d, 0x1d, 0xa7, 0xdf, 0x37, 0x6c, 0x53, 0xdc, 0x84, 0xe0, 0x9f, 0xa4, 0xa6, 0x86, 0xd7, 0x65, 0xdb, 0xf8, 0x15, 0x8d, 0xfe, 0x26, 0xf6, 0x49, 0x3c, 0xb5, 0x65, 0x53, 0x64, 0x1b, 0x35, 0xa1, 0x8a, 0x06, 0x3c, 0x69, 0xdd, 0xf2, 0xd0, 0x79, 0x28, 0x61, 0xfb, 0x89, 0x30, 0x19, 0x69, 0x3b, 0x59, 0xac, 0x3f, 0x35, 0x4a, 0x81, 0x2e, 0xc0, 0x54, 0x9f, 0xd8, 0xbc, 0x40, 0x3f, 0x2c, 0xa4, 0x6e, 0x0c, 0x68, 0x9c, 0x00, 0xbd, 0x02, 0xd3, 0x26, 0xd5, 0x9e, 0x58, 0x70, 0x21, 0x09, 0x23, 0x47, 0xb3, 0x34, 0x41, 0x82, 0xde, 0x0d, 0xcf, 0x32, 0x2a, 0xe9, 0x43, 0xc6, 0x84, 0x9a, 0x33, 0x8f, 0x31, 0xb6, 0xe4, 0x0d, 0x01, 0x48, 0x9f, 0x88, 0x24, 0xa5, 0x0c, 0xdf, 0x16, 0x38, 0x01, 0xe5, 0x9e, 0xd3, 0x65, 0xd6, 0x33, 0xc3, 0xae, 0xd1, 0xf4, 0x9c, 0x2e, 0x35, 0x9e, 0x45, 0x98, 0xf4, 0x03, 0xd3, 0xb2, 0x69, 0xdc, 0x5a, 0xd6, 0xd8, 0x07, 0xf1, 0x20, 0xf4, 0x87, 0xee, 0xd8, 0x1d, 0xbc, 0x52, 0xa5, 0x59, 0x15, 0x9a, 0xb2, 0x6d, 0x77, 0xe8, 0xfa, 0x3d, 0x08, 0x0e, 0x56, 0xe6, 0x68, 0x3a, 0xf9, 0x19, 0x1d, 0x29, 0xcc, 0xe7, 0x1c, 0x29, 0x24, 0x2a, 0x9c, 0x71, 0xa4, 0x50, 0xcb, 0x9d, 0xd0, 0x92, 0xbc, 0x82, 0x85, 0xc4, 0xec, 0x6b, 0xeb, 0x4d, 0x5d, 0x74, 0xcd, 0x42, 0xfa, 0x8e, 0x40, 0x68, 0xf6, 0x1a, 0x84, 0x3f, 0x3f, 0xd7, 0x13, 0x9d, 0x1f, 0x29, 0xb0, 0xb4, 0x46, 0xcf, 0xb3, 0x63, 0x8e, 0xfb, 0x30, 0x50, 0xb0, 0xd7, 0x42, 0x7c, 0x5e, 0x06, 0xc8, 0x2a, 0xa9, 0x29, 0x01, 0xcf, 0x5b, 0x83, 0x39, 0x21, 0x96, 0x33, 0x17, 0xc7, 0x00, 0xf7, 0x55, 0xfd, 0xf8, 0xa7, 0x7a, 0x1b, 0x96, 0x53, 0x35, 0xe7, 0xa7, 0x8a, 0xc9, 0xcb, 0x24, 0xac, 0xe2, 0xf1, 0xcb, 0x24, 0xea, 0x2d, 0x38, 0xde, 0x0e, 0x0c, 0x2f, 0x48, 0x35, 0x7b, 0x0c, 0x5e, 0x0a, 0xdb, 0x93, 0x79, 0x39, 0xb2, 0xae, 0x0d, 0x8b, 0xed, 0xc0, 0x71, 0x8f, 0x20, 0x94, 0xf8, 0x1d, 0xd2, 0x72, 0x67, 0x20, 0x26, 0x41, 0xf1, 0xa9, 0x2e, 0x33, 0x90, 0x61, 0xba, 0xb4, 0xb7, 0x60, 0x89, 0x61, 0xfc, 0x8e, 0xd2, 0x88, 0x13, 0x02, 0x61, 0x98, 0x96, 0x7b, 0x1f, 0x8e, 0x49, 0xe7, 0x1c, 0x1c, 0x13, 0x73, 0x55, 0xc6, 0xc4, 0xe4, 0x1f, 0x29, 0x85, 0x90, 0x98, 0xdf, 0x2c, 0xc4, 0xfc, 0x78, 0xce, 0xc1, 0xf8, 0xeb, 0x32, 0x22, 0xe6, 0x4c, 0xbe, 0x54, 0x09, 0x10, 0x93, 0xb6, 0xce, 0x62, 0x86, 0x75, 0xee, 0xa6, 0x4e, 0xdd, 0x4b, 0x69, 0x44, 0x53, 0xa2, 0x86, 0x9f, 0xc9, 0x79, 0xfb, 0x43, 0x86, 0x9a, 0x09, 0x8b, 0x0e, 0x8f, 0xda, 0x5f, 0x4b, 0x1c, 0xb5, 0x9f, 0x1c, 0x52, 0xd3, 0xf0, 0x90, 0xfd, 0x07, 0x25, 0xa8, 0x84, 0x79, 0x29, 0x0d, 0xa7, 0x55, 0x55, 0xc8, 0x50, 0x55, 0x7c, 0x7e, 0x2d, 0x1e, 0x71, 0x7e, 0x2d, 0x8d, 0x31, 0xbf, 0x9e, 0x84, 0x0a, 0xfd, 0x41, 0x2f, 0x3a, 0xb0, 0xf9, 0xb2, 0x4c, 0x13, 0x34, 0xbc, 0x17, 0x99, 0xd8, 0xd4, 0x98, 0x26, 0x96, 0x40, 0xe8, 0x4c, 0x27, 0x11, 0x3a, 0x37, 0xc3, 0xb9, 0xaf, 0x9c, 0x3e, 0x11, 0x0b, 0x25, 0x66, 0xce, 0x7a, 0x89, 0x6d, 0xf0, 0x4a, 0x7a, 0x1b, 0x3c, 0xe2, 0x1f, 0x39, 0xdf, 0xb1, 0x26, 0x5b, 0x26, 0x5b, 0x5c, 0x6b, 0xd3, 0xf4, 0xbb, 0x69, 0x7e, 0x9e, 0xae, 0x7f, 0x9b, 0x21, 0x72, 0xe2, 0x26, 0xc8, 0xdd, 0xe7, 0xeb, 0xd2, 0x61, 0xa8, 0x92, 0x31, 0x8d, 0x85, 0x2e, 0x23, 0x7e, 0x00, 0xba, 0x0b, 0x4b, 0x49, 0x24, 0xdf, 0xa1, 0xdc, 0x5f, 0x0e, 0xa4, 0xf8, 0x67, 0xf1, 0x60, 0x30, 0x07, 0x3f, 0x7b, 0x33, 0x05, 0xf5, 0x18, 0xdb, 0x78, 0xaf, 0xca, 0xa8, 0xb0, 0x43, 0x9b, 0x5c, 0x0a, 0x14, 0x46, 0x83, 0x15, 0xc3, 0xe3, 0xd9, 0x6c, 0x51, 0x51, 0xe1, 0x29, 0x0d, 0xba, 0xa2, 0x21, 0x11, 0xbf, 0xbf, 0xcf, 0xf2, 0xa7, 0xd8, 0x8a, 0x46, 0x24, 0x35, 0xe8, 0xe6, 0x31, 0x7e, 0x66, 0x05, 0x7a, 0xc7, 0x31, 0x31, 0x35, 0xe8, 0x49, 0xad, 0x4c, 0x12, 0xd6, 0x1c, 0x13, 0x47, 0x43, 0xad, 0x7c, 0xd8, 0xa1, 0x56, 0x49, 0x0c, 0xb5, 0x25, 0x98, 0xf2, 0xb0, 0xe1, 0x3b, 0x36, 0x37, 0x49, 0xfe, 0x45, 0x3a, 0xa2, 0x8f, 0x7d, 0x9f, 0x94, 0xc1, 0x63, 0x33, 0xfe, 0x19, 0x8b, 0x23, 0x67, 0x87, 0xc4, 0x91, 0x43, 0xd0, 0xb9, 0x89, 0x38, 0xb2, 0x3a, 0x24, 0x8e, 0x1c, 0x0b, 0x9c, 0x1b, 0x45, 0xcc, 0x73, 0xa3, 0x22, 0xe6, 0x78, 0xc8, 0x39, 0x2f, 0x87, 0x9c, 0xb7, 0xe3, 0x2b, 0xeb, 0x5a, 0x1a, 0xab, 0x30, 0x7c, 0x49, 0x1d, 0x1f, 0xdb, 0x0b, 0xd2, 0xd8, 0x46, 0x97, 0xf8, 0x0e, 0x3e, 0x4a, 0xef, 0xfd, 0x4a, 0x5b, 0x51, 0x6c, 0x73, 0xff, 0xf3, 0x74, 0x05, 0x7f, 0xaf, 0xc0, 0x72, 0x6a, 0xe8, 0x72, 0x67, 0xf0, 0x5a, 0x02, 0x40, 0x3c, 0x14, 0xb9, 0x2b, 0xf0, 0xc3, 0x0d, 0x09, 0x3f, 0x7c, 0x69, 0x18, 0x4b, 0x0e, 0x7c, 0xf8, 0xe8, 0x90, 0xde, 0x6f, 0x2b, 0x80, 0x32, 0x76, 0x21, 0x6e, 0x8a, 0x25, 0xc1, 0x21, 0xb6, 0x26, 0xf9, 0xaa, 0xe0, 0xdd, 0x68, 0x55, 0x50, 0x38, 0xcc, 0xce, 0x4b, 0x88, 0x35, 0xda, 0x80, 0xaa, 0xbc, 0xf9, 0x78, 0x5d, 0xae, 0xcc, 0x6a, 0x7e, 0x65, 0xa8, 0x81, 0x30, 0x62, 0xf5, 0x67, 0x05, 0x38, 0xb3, 0xeb, 0x9a, 0x89, 0x90, 0x97, 0x17, 0x36, 0xbe, 0xab, 0xbd, 0x29, 0xe3, 0xad, 0x8e, 0xa8, 0x89, 0xe2, 0x51, 0x34, 0x81, 0xbe, 0x9e, 0x85, 0x88, 0xbb, 0x2d, 0x9d, 0x5d, 0x0f, 0x6f, 0xe0, 0x08, 0x70, 0xdc, 0x27, 0x1d, 0x09, 0x2a, 0x9c, 0xcd, 0xaf, 0x00, 0x0f, 0x8f, 0xff, 0x37, 0xcc, 0x6f, 0x3c, 0xc3, 0x9d, 0xf6, 0x81, 0xdd, 0x39, 0x84, 0xd6, 0x6b, 0x50, 0xec, 0xf4, 0x4d, 0x7e, 0x6a, 0x46, 0x7e, 0xc6, 0x23, 0xfe, 0xa2, 0x1c, 0xf1, 0xeb, 0x50, 0x8b, 0x4a, 0xe0, 0xe3, 0x70, 0x89, 0x8c, 0x43, 0x93, 0x10, 0x13, 0xe1, 0xb3, 0x1a, 0xff, 0xe2, 0xe9, 0xd8, 0x63, 0x37, 0x9c, 0x58, 0x3a, 0xf6, 0x3c, 0x79, 0x1a, 0x29, 0xca, 0xd3, 0x88, 0xfa, 0x5d, 0x05, 0x66, 0x48, 0x09, 0x9f, 0xa8, 0xfe, 0x7c, 0xd9, 0x5d, 0x8c, 0x96, 0xdd, 0xe1, 0xea, 0xbd, 0x14, 0x5f, 0xbd, 0x47, 0x35, 0x9f, 0xa4, 0xc9, 0xe9, 0x9a, 0x4f, 0x85, 0xe9, 0xd8, 0xf3, 0xd4, 0xb3, 0x30, 0xcb, 0xea, 0xc6, 0x5b, 0x5e, 0x83, 0xe2, 0xc0, 0xeb, 0x89, 0xfe, 0x1b, 0x78, 0x3d, 0xf5, 0x5b, 0x0a, 0x54, 0x1b, 0x41, 0x60, 0x74, 0xf6, 0x0f, 0xd1, 0x80, 0xb0, 0x72, 0x85, 0x78, 0xe5, 0xd2, 0x8d, 0x88, 0xaa, 0x5b, 0xca, 0xa9, 0xee, 0xa4, 0x54, 0x5d, 0x15, 0xe6, 0x44, 0x5d, 0x72, 0x2b, 0xbc, 0x05, 0xa8, 0xe5, 0x78, 0xc1, 0x3d, 0xc7, 0x7b, 0x6a, 0x78, 0xe6, 0xe1, 0x56, 0xd8, 0x08, 0x4a, 0xfc, 0xd1, 0x8c, 0xe2, 0xf9, 0x49, 0x8d, 0xfe, 0x56, 0x5f, 0x82, 0x63, 0x92, 0xbc, 0xdc, 0x82, 0x6f, 0xc1, 0x0c, 0x0d, 0x0b, 0xf8, 0xe2, 0xeb, 0xe5, 0x38, 0xe0, 0x63, 0xd4, 0xc3, 0x0d, 0xeb, 0xb0, 0x40, 0x02, 0x44, 0x9a, 0x1e, 0xfa, 0x97, 0x2b, 0x89, 0xf5, 0xc9, 0x72, 0x4a, 0x44, 0x62, 0x6d, 0xf2, 0x0b, 0x05, 0x26, 0x19, 0xb6, 0x23, 0x19, 0xb4, 0x9d, 0x24, 0x13, 0xaf, 0xeb, 0xe8, 0x81, 0xd1, 0x0d, 0x1f, 0x24, 0x21, 0x09, 0x3b, 0x46, 0x97, 0x9e, 0xc2, 0xd1, 0x4c, 0xd3, 0xea, 0x62, 0x3f, 0x10, 0x27, 0xc7, 0x33, 0x24, 0x6d, 0x9d, 0x25, 0x11, 0xc5, 0xd0, 0x03, 0xf6, 0x12, 0xdd, 0x2d, 0xa5, 0xbf, 0xd1, 0x79, 0x76, 0xaa, 0x33, 0xfc, 0xb8, 0x94, 0x9e, 0xf6, 0xd4, 0xa1, 0x9c, 0x38, 0xe7, 0x0c, 0xbf, 0xd1, 0x05, 0x28, 0xd1, 0x8d, 0xfc, 0xe9, 0x61, 0x5a, 0xa2, 0x24, 0xc4, 0x2a, 0x5c, 0xcb, 0xb6, 0xb1, 0xc9, 0x5f, 0xcb, 0xe0, 0x5f, 0xea, 0xbb, 0x80, 0xe2, 0xca, 0xe3, 0x1d, 0x74, 0x01, 0xa6, 0xa8, 0x6e, 0x45, 0x54, 0xbd, 0x90, 0x12, 0xad, 0x71, 0x02, 0xf5, 0x6b, 0x80, 0x58, 0x59, 0x52, 0x24, 0x7d, 0x98, 0x0e, 0x1c, 0x12, 0x53, 0xff, 0x50, 0x81, 0x63, 0x92, 0x74, 0x5e, 0xbf, 0x97, 0x64, 0xf1, 0x19, 0xd5, 0xe3, 0xa2, 0xdf, 0x96, 0x26, 0xf8, 0x0b, 0xe9, 0x6a, 0xfc, 0x0f, 0x4d, 0xee, 0xff, 0xa0, 0x00, 0x34, 0x06, 0xc1, 0x3e, 0xdf, 0x14, 0x8e, 0x77, 0xa2, 0x92, 0xe8, 0xc4, 0x3a, 0x94, 0x5d, 0xc3, 0xf7, 0x9f, 0x3a, 0x9e, 0x58, 0xf0, 0x86, 0xdf, 0x74, 0x2b, 0x77, 0xc0, 0x1f, 0x12, 0xa9, 0x68, 0xf4, 0x37, 0x7a, 0x01, 0xe6, 0xd8, 0x4b, 0x39, 0xba, 0x61, 0x9a, 0x9e, 0x00, 0x91, 0x56, 0xb4, 0x2a, 0x4b, 0x6d, 0xb0, 0x44, 0x42, 0x66, 0xd1, 0x63, 0x9d, 0xe0, 0x40, 0x0f, 0x9c, 0xc7, 0xd8, 0xe6, 0x8b, 0xd8, 0xaa, 0x48, 0xdd, 0x21, 0x89, 0xec, 0x88, 0xb8, 0x6b, 0xf9, 0x81, 0x27, 0xc8, 0xc4, 0x61, 0x3a, 0x4f, 0xa5, 0x64, 0xea, 0x1f, 0x2b, 0x50, 0x6b, 0x0d, 0x7a, 0x3d, 0xa6, 0xdc, 0xa3, 0x74, 0xf2, 0x45, 0xde, 0x94, 0x42, 0xda, 0xe4, 0x23, 0x45, 0xf1, 0x26, 0x7e, 0x2a, 0xfb, 0x6e, 0x57, 0x61, 0x21, 0x56, 0x63, 0x6e, 0x38, 0xd2, 0x52, 0x43, 0x91, 0x97, 0x1a, 0x6a, 0x03, 0x10, 0xdb, 0x6a, 0x3a, 0x72, 0x2b, 0xd5, 0xe3, 0x70, 0x4c, 0x12, 0xc1, 0xa7, 0xe2, 0x8b, 0x50, 0xe5, 0x80, 0x46, 0x6e, 0x10, 0x27, 0xa0, 0x4c, 0x5c, 0x6a, 0xc7, 0x32, 0x05, 0x72, 0x66, 0xda, 0x75, 0xcc, 0x35, 0xcb, 0xf4, 0xd4, 0x2f, 0x43, 0x95, 0xbf, 0x98, 0xc0, 0x69, 0xef, 0xc0, 0x1c, 0x3f, 0x68, 0xd5, 0xa5, 0x2b, 0xc6, 0x27, 0x32, 0x50, 0xb3, 0x42, 0x15, 0x76, 0xfc, 0x53, 0xfd, 0x3a, 0xd4, 0x59, 0xb4, 0x20, 0x09, 0x16, 0x0d, 0xbc, 0x03, 0x02, 0xb4, 0x36, 0x44, 0xbe, 0xcc, 0x59, 0xf5, 0xe2, 0x9f, 0xea, 0x69, 0x38, 0x99, 0x29, 0x9f, 0xb7, 0xde, 0x85, 0x5a, 0x94, 0xc1, 0xee, 0xc1, 0x86, 0x70, 0x20, 0x25, 0x06, 0x07, 0x5a, 0x0a, 0x43, 0xf8, 0x82, 0x98, 0xb9, 0x68, 0x94, 0x1e, 0x2d, 0x01, 0x8b, 0x79, 0x4b, 0xc0, 0x92, 0xb4, 0x04, 0x54, 0x37, 0x43, 0x1d, 0xf2, 0x85, 0xf8, 0x6d, 0xba, 0x55, 0xc0, 0xca, 0x16, 0x4e, 0xed, 0x54, 0x76, 0xfb, 0x18, 0x91, 0x16, 0xa3, 0x57, 0x2f, 0x40, 0x55, 0x76, 0x6f, 0x31, 0x8f, 0xa5, 0xc8, 0x1e, 0xeb, 0xff, 0xc0, 0x92, 0x26, 0x21, 0x00, 0xef, 0x61, 0x23, 0x18, 0x78, 0xd8, 0x47, 0x6f, 0x41, 0x3d, 0xe3, 0xf1, 0x22, 0x9d, 0xaf, 0x0c, 0x99, 0x98, 0xe5, 0xd4, 0x1b, 0x46, 0x9b, 0x6c, 0x5d, 0xf8, 0x12, 0xcc, 0x53, 0x84, 0x62, 0xec, 0x66, 0x2f, 0xd3, 0x11, 0x7d, 0xfb, 0x66, 0x2b, 0xba, 0xc6, 0x6b, 0x86, 0xef, 0x6d, 0xf0, 0xf2, 0x33, 0xcf, 0xd8, 0xde, 0x81, 0xf2, 0x1e, 0xaf, 0x17, 0x1f, 0x90, 0x6a, 0x86, 0x32, 0x12, 0x2d, 0xd0, 0x42, 0x1e, 0x75, 0x1b, 0xe6, 0x39, 0x4d, 0xd8, 0xbc, 0xdb, 0x43, 0x41, 0x31, 0xac, 0x79, 0xb9, 0x70, 0x17, 0xf5, 0x87, 0x05, 0x98, 0x4b, 0xf8, 0xf8, 0x57, 0x13, 0x0b, 0xba, 0x2c, 0x73, 0x4c, 0x2c, 0xe7, 0x6e, 0x48, 0xde, 0x5e, 0x86, 0xe0, 0x0c, 0xbf, 0x04, 0xba, 0x01, 0xb5, 0x04, 0x9e, 0x53, 0x60, 0xb9, 0xeb, 0xf9, 0x8a, 0xd1, 0xe6, 0x65, 0xb0, 0xa7, 0x8f, 0xde, 0x8c, 0xe9, 0xb5, 0x94, 0x5e, 0x86, 0x26, 0x74, 0x16, 0x29, 0xf4, 0xe8, 0x13, 0xcd, 0x22, 0x9f, 0x7e, 0xef, 0xf9, 0x84, 0x9f, 0xdb, 0xa7, 0xfa, 0x1c, 0xcc, 0xec, 0xe6, 0x3d, 0x69, 0x54, 0x12, 0x30, 0xd1, 0x37, 0x60, 0xf1, 0x9e, 0xd5, 0xc3, 0xfe, 0x81, 0x1f, 0xe0, 0x7e, 0x93, 0xce, 0x0a, 0x7b, 0x16, 0xf6, 0xd0, 0x2a, 0x00, 0x35, 0x4a, 0xd7, 0xb1, 0xc2, 0x27, 0x56, 0x62, 0x29, 0xea, 0x4f, 0x15, 0x98, 0x8f, 0x18, 0xc7, 0xc1, 0x02, 0xbf, 0x0e, 0x93, 0x7b, 0xbe, 0xd8, 0xd0, 0x4d, 0x1c, 0x73, 0x65, 0x55, 0x41, 0x2b, 0xed, 0xf9, 0x4d, 0x13, 0xbd, 0x01, 0x30, 0xf0, 0xb1, 0xc9, 0x8f, 0xbd, 0x47, 0xa0, 0xb3, 0x2b, 0x84, 0x94, 0x9d, 0x83, 0xdf, 0x80, 0x19, 0xcb, 0x76, 0x4c, 0x4c, 0x21, 0x11, 0xe6, 0x28, 0x64, 0x36, 0x30, 0xda, 0x5d, 0x1f, 0x9b, 0xea, 0xef, 0x45, 0xc0, 0x86, 0x2f, 0x72, 0x0b, 0xd5, 0x3f, 0x11, 0x71, 0x91, 0xe8, 0x76, 0x3e, 0x66, 0x1e, 0xc0, 0x02, 0x9b, 0xde, 0xf6, 0xc2, 0x32, 0x33, 0xaf, 0xac, 0x25, 0x1a, 0xa7, 0xd5, 0x2c, 0x1e, 0x11, 0x0b, 0x26, 0xd4, 0x82, 0xe3, 0xd1, 0x42, 0x25, 0x2e, 0xad, 0x30, 0x5a, 0xda, 0x62, 0x27, 0xb6, 0xff, 0x2f, 0x18, 0xd5, 0x5b, 0x70, 0x3c, 0x71, 0x2b, 0x65, 0xfc, 0x43, 0xa0, 0xf7, 0x12, 0x5b, 0xb6, 0x91, 0x97, 0xb8, 0x2a, 0x5f, 0x86, 0x1c, 0x76, 0x7f, 0x88, 0xdf, 0xcb, 0xdb, 0x85, 0x13, 0xd2, 0x7e, 0xb2, 0x54, 0x97, 0x1b, 0x89, 0x65, 0xc3, 0xd9, 0x7c, 0x79, 0x89, 0xf5, 0xc3, 0x7f, 0x28, 0xb0, 0x98, 0x45, 0x70, 0xc4, 0x63, 0x8e, 0x0f, 0x73, 0x2e, 0x52, 0xbf, 0x36, 0xaa, 0x42, 0x9f, 0xc9, 0xb1, 0xd0, 0x16, 0xbb, 0x86, 0x39, 0xba, 0x4f, 0x8a, 0xe3, 0xf5, 0xc9, 0x2f, 0x0a, 0xb1, 0xa3, 0xbc, 0x21, 0x57, 0x25, 0x3f, 0xc1, 0xfe, 0xf9, 0x5a, 0xe2, 0xa6, 0xe4, 0xcb, 0x99, 0x8c, 0x23, 0x2e, 0x4a, 0x6a, 0x59, 0xdb, 0x42, 0x57, 0x47, 0x49, 0xfa, 0xc2, 0xde, 0x93, 0xfc, 0xad, 0x02, 0xcc, 0xc9, 0x1d, 0x82, 0xde, 0xcd, 0xb8, 0x26, 0x79, 0x66, 0x44, 0x03, 0xa5, 0x5b, 0x92, 0xfc, 0x5a, 0x62, 0x61, 0xfc, 0x6b, 0x89, 0xc5, 0xf1, 0xae, 0x25, 0xde, 0x85, 0xb9, 0xa7, 0x9e, 0x15, 0x18, 0x8f, 0x7a, 0x58, 0xef, 0x19, 0x07, 0xd8, 0xcb, 0x9a, 0x61, 0x93, 0xae, 0xa8, 0x2a, 0x58, 0x1e, 0x12, 0x0e, 0xba, 0x60, 0x7e, 0x6a, 0xb8, 0x7c, 0xdd, 0x2d, 0x85, 0xf2, 0xed, 0xa7, 0x86, 0xcb, 0x78, 0x28, 0x89, 0xfa, 0xad, 0x02, 0x1c, 0xcf, 0xbc, 0x4c, 0xf7, 0xc9, 0x55, 0x74, 0x29, 0xae, 0xa2, 0xc3, 0xdc, 0x50, 0x2c, 0x1e, 0xea, 0x86, 0x62, 0x33, 0x47, 0x61, 0x59, 0x58, 0x91, 0xe1, 0x7a, 0x53, 0xff, 0x42, 0x81, 0xb2, 0xa8, 0xd4, 0xc8, 0xfb, 0x82, 0xcb, 0x03, 0x42, 0xa6, 0xd3, 0x3b, 0x1d, 0xb6, 0x61, 0x3b, 0xba, 0x8f, 0x49, 0x2c, 0x3d, 0xf2, 0x76, 0xd6, 0x22, 0xe5, 0x5b, 0x73, 0x3c, 0xbc, 0x65, 0xd8, 0x4e, 0x9b, 0x31, 0xa1, 0x06, 0xd4, 0x98, 0x3c, 0x2a, 0x8a, 0x08, 0x1d, 0x39, 0x51, 0xce, 0x51, 0x06, 0x22, 0x84, 0x08, 0xf3, 0xd5, 0xbf, 0x56, 0x60, 0x3e, 0xa1, 0xd9, 0x5f, 0xbd, 0x46, 0x7c, 0xbf, 0x08, 0x33, 0xb1, 0x5e, 0x1e, 0xd1, 0x80, 0x35, 0x58, 0x10, 0x78, 0x2f, 0x1f, 0x07, 0xe3, 0xdd, 0x8e, 0x9b, 0xe7, 0x1c, 0x6d, 0x1c, 0xb0, 0x38, 0xea, 0x0e, 0xcc, 0x1b, 0x4f, 0x0c, 0xab, 0x47, 0x2d, 0x68, 0xac, 0x10, 0x65, 0x2e, 0xa4, 0x0f, 0x23, 0x31, 0xd6, 0xee, 0xb1, 0xee, 0xc8, 0x01, 0xa5, 0x8d, 0xae, 0x2a, 0xfa, 0x7e, 0x0c, 0xf1, 0x38, 0xf4, 0xaa, 0xa2, 0xef, 0x87, 0xe5, 0xd1, 0x0b, 0x2d, 0xf4, 0x8e, 0xa6, 0xcf, 0x1f, 0xf6, 0xc9, 0x2f, 0x8f, 0xd0, 0xde, 0xa3, 0xa4, 0x44, 0x61, 0x7d, 0xe3, 0x23, 0xc7, 0xd3, 0xe3, 0xfc, 0xd3, 0x23, 0x14, 0x46, 0x39, 0x5a, 0xa1, 0x10, 0xf5, 0xcf, 0x14, 0xa8, 0x84, 0x7e, 0x64, 0x44, 0x0f, 0x35, 0x61, 0x91, 0xde, 0xfe, 0x49, 0x6a, 0x78, 0x44, 0x27, 0x21, 0xc2, 0xd4, 0x90, 0xb5, 0xdc, 0x80, 0x1a, 0x15, 0x15, 0x57, 0xf5, 0xa8, 0x8e, 0xf2, 0x45, 0x35, 0x59, 0x40, 0xf9, 0x97, 0x05, 0x40, 0x69, 0x57, 0xf2, 0x2b, 0x63, 0x64, 0xf1, 0x4e, 0x2b, 0x8d, 0xdf, 0xe9, 0xf7, 0xe1, 0x58, 0xc7, 0xe9, 0xf7, 0x2d, 0x7a, 0x73, 0xcc, 0xf1, 0x0e, 0xc6, 0x33, 0xb7, 0x05, 0xc6, 0xc3, 0xf4, 0xc4, 0xd4, 0xf7, 0x0e, 0x9c, 0xd0, 0xb0, 0xe3, 0x62, 0x3b, 0x74, 0xfd, 0x0f, 0x9d, 0xee, 0x21, 0xe2, 0xdb, 0x53, 0x50, 0xcf, 0xe2, 0xe7, 0xfb, 0x27, 0x03, 0xa8, 0xaf, 0xed, 0xe3, 0xce, 0x63, 0xba, 0xfc, 0x3a, 0x0a, 0x66, 0xab, 0x0e, 0xe5, 0x9e, 0xd3, 0x61, 0xcf, 0x3c, 0xf3, 0x2d, 0x46, 0xf1, 0x3d, 0xe4, 0x74, 0xe7, 0x34, 0x9c, 0xcc, 0x2c, 0x96, 0xd7, 0x0a, 0x41, 0xed, 0x3e, 0x0e, 0x36, 0x9e, 0x60, 0x3b, 0x0c, 0x9f, 0xd5, 0x1f, 0x17, 0x62, 0x81, 0x3a, 0xcd, 0x3a, 0x04, 0xd6, 0x0d, 0xb5, 0x20, 0x5a, 0x39, 0xe8, 0x98, 0x70, 0xb3, 0x37, 0x4b, 0xd9, 0x8b, 0xc2, 0xd9, 0x87, 0xdd, 0xb4, 0x10, 0xfa, 0x54, 0x69, 0xf4, 0x1a, 0x53, 0x98, 0x96, 0x80, 0x40, 0x14, 0x93, 0x10, 0x88, 0xf7, 0x00, 0xc5, 0x43, 0x71, 0xbe, 0xdd, 0x50, 0x1a, 0xe3, 0x01, 0xaa, 0x9a, 0x9b, 0x7c, 0x2a, 0x2d, 0xe7, 0x19, 0xa9, 0xc9, 0x23, 0x3d, 0x23, 0xa5, 0xae, 0xc2, 0x29, 0x12, 0x60, 0x6f, 0xe2, 0xc0, 0xb3, 0x3a, 0xeb, 0xd8, 0xef, 0x78, 0x96, 0x1b, 0x38, 0x21, 0xfc, 0x4a, 0xd5, 0xe1, 0x74, 0x4e, 0x3e, 0x57, 0xf7, 0x3b, 0x30, 0x63, 0x46, 0xc9, 0x59, 0x3b, 0x5e, 0x49, 0x5e, 0x2d, 0xce, 0xa0, 0x7e, 0x00, 0xb5, 0x24, 0x41, 0xe6, 0x4e, 0x12, 0x82, 0xd2, 0x3e, 0xee, 0xb9, 0xe2, 0xaa, 0x1f, 0xf9, 0x4d, 0xb4, 0xce, 0xd6, 0x2e, 0x8f, 0xf1, 0x81, 0x38, 0x11, 0xa9, 0xd0, 0x94, 0x2f, 0xe1, 0x83, 0xb0, 0x6d, 0xd2, 0xbb, 0x26, 0x9e, 0xd5, 0x49, 0xb6, 0x2d, 0x23, 0x3f, 0x6a, 0x1b, 0xe9, 0xb6, 0x3e, 0x4b, 0xe6, 0x6d, 0x3b, 0x9d, 0xfb, 0x66, 0x0a, 0xe5, 0x05, 0xd7, 0x31, 0xf9, 0x6f, 0xf5, 0x07, 0x0a, 0x2c, 0xa4, 0x28, 0xc6, 0x3c, 0xe5, 0x7a, 0x05, 0xa6, 0x45, 0xb9, 0x85, 0x34, 0xa4, 0x99, 0xc9, 0xd2, 0x04, 0x09, 0x6a, 0xc2, 0x42, 0x64, 0xd1, 0x82, 0xaf, 0x98, 0xee, 0x8b, 0xf8, 0xc2, 0x85, 0x56, 0xb7, 0xd6, 0x49, 0xa4, 0xa8, 0x1d, 0xa8, 0x25, 0xa9, 0xc6, 0x19, 0x53, 0x87, 0xaa, 0xaf, 0xfa, 0xb7, 0x0a, 0x4c, 0xb1, 0xb4, 0xcc, 0xce, 0x96, 0xa6, 0x83, 0x42, 0x72, 0x3a, 0x78, 0x13, 0x66, 0x98, 0x1c, 0x3d, 0xbc, 0xe8, 0x39, 0x27, 0x6f, 0xf4, 0x33, 0xd1, 0x74, 0xb4, 0x42, 0x3f, 0xfc, 0x4d, 0x9a, 0xc1, 0xec, 0x85, 0xae, 0x4c, 0x04, 0x70, 0x7d, 0x86, 0xa6, 0x51, 0x97, 0x4b, 0x42, 0x66, 0xbe, 0x86, 0x19, 0xe1, 0x9b, 0xf9, 0xd6, 0xd6, 0x12, 0x7d, 0xa5, 0x33, 0xb5, 0xd5, 0xad, 0xee, 0xd0, 0x67, 0x34, 0xd3, 0x5b, 0xd4, 0xe8, 0x2d, 0x19, 0xe8, 0xf0, 0x42, 0x0a, 0x6b, 0x20, 0xb1, 0x0d, 0x3c, 0xf6, 0x1c, 0x3e, 0xc7, 0x3b, 0x7c, 0x08, 0x27, 0x72, 0x69, 0xd0, 0xdb, 0xe1, 0x9b, 0xc5, 0xa6, 0x67, 0x3d, 0xe1, 0x1b, 0x0b, 0x73, 0xf2, 0xfb, 0x28, 0x6b, 0x94, 0x60, 0x9d, 0xe6, 0x8b, 0xd7, 0x8c, 0xd9, 0xd7, 0xc5, 0x17, 0xa1, 0x2c, 0xfe, 0x55, 0x01, 0x9a, 0x86, 0xe2, 0xce, 0x5a, 0xab, 0x36, 0x41, 0x7e, 0xec, 0xae, 0xb7, 0x6a, 0x0a, 0x2a, 0x43, 0xa9, 0xbd, 0xb6, 0xd3, 0xaa, 0x15, 0x2e, 0xf6, 0xa1, 0x96, 0x7c, 0xad, 0x1f, 0x2d, 0xc3, 0xb1, 0x96, 0xb6, 0xdd, 0x6a, 0xdc, 0x6f, 0xec, 0x34, 0xb7, 0xb7, 0xf4, 0x96, 0xd6, 0x7c, 0xbf, 0xb1, 0xb3, 0x51, 0x9b, 0x40, 0xe7, 0xe0, 0x74, 0x3c, 0xe3, 0xc1, 0x76, 0x7b, 0x47, 0xdf, 0xd9, 0xd6, 0xd7, 0xb6, 0xb7, 0x76, 0x1a, 0xcd, 0xad, 0x0d, 0xad, 0xa6, 0xa0, 0xd3, 0x70, 0x22, 0x4e, 0x72, 0xb7, 0xb9, 0xde, 0xd4, 0x36, 0xd6, 0xc8, 0xef, 0xc6, 0xc3, 0x5a, 0xe1, 0xe2, 0xdb, 0x50, 0x95, 0xee, 0x82, 0x91, 0x2a, 0xb5, 0xb6, 0xd7, 0x6b, 0x13, 0xa8, 0x0a, 0x95, 0xb8, 0x9c, 0x32, 0x94, 0xb6, 0xb6, 0xd7, 0x37, 0x6a, 0x05, 0x04, 0x30, 0xb5, 0xd3, 0xd0, 0xee, 0x6f, 0xec, 0xd4, 0x8a, 0x17, 0x5f, 0x85, 0x95, 0xbc, 0x3b, 0x91, 0xa8, 0x02, 0x93, 0x9b, 0xd8, 0xeb, 0xe2, 0xda, 0x04, 0x61, 0x69, 0x13, 0x2b, 0x09, 0x6a, 0xca, 0xc5, 0x5b, 0xc9, 0x27, 0x7d, 0x30, 0x5a, 0x80, 0x6a, 0xbb, 0xb1, 0xb5, 0x7e, 0x77, 0xfb, 0xab, 0xba, 0xb6, 0xd1, 0x58, 0xff, 0xa0, 0x36, 0x81, 0x16, 0xa1, 0x26, 0x92, 0xb6, 0xb6, 0x77, 0x58, 0xaa, 0x72, 0xf1, 0x71, 0x62, 0x99, 0x8b, 0xd1, 0x71, 0x58, 0x08, 0x6b, 0xa9, 0xaf, 0x69, 0x1b, 0x8d, 0x9d, 0x0d, 0x52, 0x79, 0x29, 0x59, 0xdb, 0xdd, 0xda, 0x6a, 0x6e, 0xdd, 0xaf, 0x29, 0x44, 0x6a, 0x94, 0xbc, 0xf1, 0xd5, 0x26, 0x21, 0x2e, 0xc8, 0xc4, 0xbb, 0x5b, 0x5f, 0xda, 0xda, 0xfe, 0xca, 0x56, 0xad, 0x78, 0xf1, 0xff, 0xc7, 0x71, 0x3d, 0xd1, 0x54, 0x74, 0x12, 0x96, 0x53, 0x25, 0xea, 0x1b, 0xef, 0x6f, 0x6c, 0xed, 0xd4, 0x26, 0xe4, 0xcc, 0xf6, 0x4e, 0x43, 0x8b, 0x32, 0x95, 0x64, 0xe6, 0x76, 0xab, 0x15, 0x66, 0x16, 0xe4, 0xcc, 0xf5, 0x8d, 0x87, 0x1b, 0x11, 0x67, 0xf1, 0xe2, 0xf3, 0x00, 0xd1, 0x90, 0x43, 0x33, 0x30, 0xbd, 0xb6, 0xbd, 0xbb, 0xb5, 0xb3, 0xa1, 0xd5, 0x26, 0x88, 0x96, 0xef, 0x37, 0x76, 0xef, 0x6f, 0xd4, 0x94, 0x8b, 0x17, 0x60, 0x36, 0x6e, 0x80, 0x84, 0xae, 0xfd, 0x41, 0x7b, 0x67, 0x63, 0x93, 0x68, 0x64, 0x16, 0xca, 0x6b, 0xf7, 0xb5, 0xed, 0xdd, 0xd6, 0xbd, 0x76, 0x4d, 0xb9, 0xf6, 0x5f, 0x8b, 0xe1, 0xf1, 0x42, 0x1b, 0x7b, 0xf4, 0x5e, 0xcc, 0x3a, 0x4c, 0x8b, 0xff, 0x07, 0x22, 0x6d, 0xf4, 0xc8, 0xff, 0xbf, 0xa4, 0x7e, 0x32, 0x33, 0x8f, 0x87, 0x12, 0x13, 0xe8, 0x7d, 0x7a, 0x60, 0x13, 0x7b, 0x50, 0xef, 0x6c, 0x62, 0xdf, 0x3c, 0xf5, 0x6e, 0x5f, 0xfd, 0xdc, 0x10, 0x8a, 0x50, 0xee, 0x07, 0x30, 0x27, 0xbf, 0x5c, 0x8b, 0xce, 0xc9, 0xa7, 0x02, 0x19, 0x8f, 0xe2, 0xd6, 0xd5, 0x61, 0x24, 0xa1, 0x68, 0x1d, 0x6a, 0xc9, 0x97, 0x6b, 0x91, 0x84, 0x51, 0xca, 0x79, 0x18, 0xb7, 0xfe, 0xfc, 0x70, 0xa2, 0x78, 0x01, 0xa9, 0x07, 0x59, 0x9f, 0x1b, 0xfe, 0xc4, 0x65, 0x46, 0x01, 0x79, 0xef, 0x60, 0x32, 0xe5, 0xc8, 0x13, 0x2d, 0x4a, 0xbc, 0x81, 0x9a, 0xf1, 0x5c, 0xa2, 0xac, 0x9c, 0xec, 0xa7, 0xf2, 0xd4, 0x09, 0xf4, 0xbf, 0x60, 0x3e, 0x71, 0xe9, 0x01, 0x49, 0x8c, 0xd9, 0x77, 0x39, 0xea, 0xcf, 0x0d, 0xa5, 0x91, 0x7b, 0x35, 0x7e, 0xb1, 0x21, 0xd9, 0xab, 0x19, 0x17, 0x26, 0x92, 0xbd, 0x9a, 0x79, 0x2f, 0x82, 0x1a, 0xa2, 0x74, 0x89, 0x41, 0x36, 0xc4, 0xac, 0x4b, 0x13, 0xf5, 0x73, 0x43, 0x28, 0xe2, 0x0a, 0x49, 0x5c, 0x63, 0x90, 0x15, 0x92, 0x7d, 0x41, 0xa2, 0xfe, 0xdc, 0x50, 0x9a, 0x64, 0x4f, 0x46, 0x18, 0xe9, 0x74, 0x4f, 0xa6, 0x20, 0xfc, 0xe9, 0x9e, 0x4c, 0x43, 0xac, 0x79, 0x4f, 0x26, 0x50, 0xcd, 0xea, 0x50, 0x9c, 0x64, 0x56, 0x4f, 0x66, 0x63, 0x29, 0xd5, 0x09, 0xf4, 0x14, 0x56, 0xf2, 0x70, 0x6c, 0xe8, 0xe5, 0x43, 0xc0, 0xed, 0xea, 0xaf, 0x8c, 0x47, 0x1c, 0x16, 0x8c, 0x01, 0xa5, 0x57, 0x5c, 0xe8, 0x05, 0x59, 0xdd, 0x39, 0x2b, 0xba, 0xfa, 0x8b, 0xa3, 0xc8, 0xc2, 0x62, 0xee, 0x43, 0x59, 0x20, 0xe4, 0x90, 0xe4, 0x02, 0x13, 0xc8, 0xbc, 0xfa, 0xa9, 0xec, 0xcc, 0x50, 0xd0, 0x5b, 0x50, 0x22, 0xa9, 0x68, 0x39, 0x49, 0x27, 0x04, 0xac, 0xa4, 0x33, 0x42, 0xe6, 0x06, 0x4c, 0x31, 0xe8, 0x17, 0x92, 0x0e, 0x51, 0x25, 0x68, 0x5a, 0xbd, 0x9e, 0x95, 0x15, 0x8a, 0x68, 0xb1, 0xff, 0xae, 0xc4, 0x91, 0x5c, 0x68, 0x35, 0xf9, 0x66, 0xbd, 0x0c, 0x19, 0xab, 0x9f, 0xc9, 0xcd, 0x8f, 0xdb, 0x6c, 0x62, 0x63, 0xf5, 0xdc, 0x90, 0x83, 0x82, 0x2c, 0x9b, 0xcd, 0x3e, 0x7e, 0x60, 0x9d, 0x9b, 0x3e, 0x9e, 0x40, 0x2f, 0xe4, 0xda, 0xbb, 0x54, 0xc4, 0x8b, 0xa3, 0xc8, 0xe2, 0x43, 0x23, 0xf9, 0xf8, 0x9c, 0x3a, 0xec, 0x61, 0xc8, 0xac, 0xa1, 0x91, 0xf3, 0xe0, 0xa4, 0x3a, 0x81, 0xf6, 0xe1, 0x58, 0xc6, 0x8b, 0x94, 0xe8, 0xc5, 0x7c, 0xff, 0x2b, 0x95, 0xf2, 0xd2, 0x48, 0xba, 0x78, 0x49, 0x19, 0xf0, 0x0d, 0xb9, 0xa4, 0x7c, 0xfc, 0x88, 0x5c, 0xd2, 0x30, 0x1c, 0x08, 0x35, 0x44, 0xee, 0x43, 0x4e, 0x64, 0x1d, 0xce, 0x67, 0x18, 0x62, 0xca, 0x63, 0xec, 0xc3, 0xb1, 0x8c, 0x5d, 0x09, 0xb9, 0xb2, 0xf9, 0xbb, 0x25, 0x72, 0x65, 0x87, 0x6d, 0x6f, 0x4c, 0xa0, 0x0f, 0x01, 0xdd, 0xc7, 0x81, 0x1c, 0xca, 0xf9, 0x48, 0x1a, 0xa8, 0xc9, 0x0d, 0x90, 0x1c, 0xfb, 0x94, 0x76, 0x42, 0xd4, 0x89, 0xab, 0x0a, 0xb2, 0xd9, 0xbd, 0xaa, 0xd4, 0xfa, 0x1d, 0x9d, 0x4f, 0x76, 0x5b, 0xde, 0x16, 0x40, 0xfd, 0xc2, 0x18, 0x94, 0x61, 0x5b, 0xec, 0xe4, 0xeb, 0xc7, 0x62, 0x09, 0x79, 0x3e, 0xdf, 0x4c, 0xe4, 0x65, 0x79, 0xba, 0xbc, 0xdc, 0x05, 0x7a, 0x18, 0xcf, 0xc5, 0x8c, 0xe9, 0x6c, 0x3e, 0x98, 0x28, 0x27, 0x9e, 0xcb, 0x32, 0xa0, 0x6b, 0xdf, 0x2b, 0xc2, 0x2c, 0x03, 0x5d, 0xf1, 0xf0, 0x73, 0x13, 0x20, 0xc2, 0x2f, 0xa2, 0xd3, 0xc9, 0x3a, 0x4a, 0xa0, 0xd0, 0xfa, 0x6a, 0x5e, 0x76, 0xdc, 0xcd, 0xc5, 0x70, 0x81, 0xb2, 0x9b, 0x4b, 0xc3, 0x1c, 0x65, 0x37, 0x97, 0x01, 0x28, 0x54, 0x27, 0xd0, 0x7b, 0x50, 0x09, 0x61, 0x68, 0xb2, 0xf1, 0x24, 0xf1, 0x74, 0xf5, 0xd3, 0x39, 0xb9, 0xf1, 0xda, 0xc5, 0xd0, 0x65, 0x72, 0xed, 0xd2, 0xc8, 0x35, 0xb9, 0x76, 0x59, 0xb0, 0xb4, 0xa8, 0xbd, 0x0c, 0x47, 0x90, 0xd1, 0x5e, 0x09, 0x57, 0x92, 0xd1, 0x5e, 0x19, 0x80, 0xa0, 0x4e, 0xdc, 0xbd, 0xf3, 0x93, 0x9f, 0xaf, 0x2a, 0x3f, 0xfd, 0xf9, 0xea, 0xc4, 0xff, 0xfd, 0x78, 0x55, 0xf9, 0xc9, 0xc7, 0xab, 0xca, 0x3f, 0x7e, 0xbc, 0xaa, 0xfc, 0xec, 0xe3, 0x55, 0xe5, 0xdb, 0xff, 0xba, 0x3a, 0xf1, 0xa1, 0xfa, 0xf8, 0x86, 0x7f, 0xd9, 0x72, 0xae, 0x74, 0x3c, 0xeb, 0x92, 0xe1, 0x5a, 0x57, 0xdc, 0xc7, 0xdd, 0x2b, 0x86, 0x6b, 0xf9, 0x57, 0xb8, 0xdc, 0x2b, 0x4f, 0x5e, 0x7d, 0x34, 0x45, 0xff, 0x23, 0xdf, 0x6b, 0xff, 0x1d, 0x00, 0x00, 0xff, 0xff, 0xc7, 0xd9, 0x11, 0x7e, 0x4b, 0x71, 0x00, 0x00, } // Reference imports to suppress errors if they are not otherwise used. var _ context.Context var _ grpc.ClientConn // This is a compile-time assertion to ensure that this generated file // is compatible with the grpc package it is being compiled against. const _ = grpc.SupportPackageIsVersion4 // RuntimeServiceClient is the client API for RuntimeService service. // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type RuntimeServiceClient interface { // Version returns the runtime name, runtime version, and runtime API version. Version(ctx context.Context, in *VersionRequest, opts ...grpc.CallOption) (*VersionResponse, error) // RunPodSandbox creates and starts a pod-level sandbox. Runtimes must ensure // the sandbox is in the ready state on success. RunPodSandbox(ctx context.Context, in *RunPodSandboxRequest, opts ...grpc.CallOption) (*RunPodSandboxResponse, error) // StopPodSandbox stops any running process that is part of the sandbox and // reclaims network resources (e.g., IP addresses) allocated to the sandbox. // If there are any running containers in the sandbox, they must be forcibly // terminated. // This call is idempotent, and must not return an error if all relevant // resources have already been reclaimed. kubelet will call StopPodSandbox // at least once before calling RemovePodSandbox. It will also attempt to // reclaim resources eagerly, as soon as a sandbox is not needed. Hence, // multiple StopPodSandbox calls are expected. StopPodSandbox(ctx context.Context, in *StopPodSandboxRequest, opts ...grpc.CallOption) (*StopPodSandboxResponse, error) // RemovePodSandbox removes the sandbox. If there are any running containers // in the sandbox, they must be forcibly terminated and removed. // This call is idempotent, and must not return an error if the sandbox has // already been removed. RemovePodSandbox(ctx context.Context, in *RemovePodSandboxRequest, opts ...grpc.CallOption) (*RemovePodSandboxResponse, error) // PodSandboxStatus returns the status of the PodSandbox. If the PodSandbox is not // present, returns an error. PodSandboxStatus(ctx context.Context, in *PodSandboxStatusRequest, opts ...grpc.CallOption) (*PodSandboxStatusResponse, error) // ListPodSandbox returns a list of PodSandboxes. ListPodSandbox(ctx context.Context, in *ListPodSandboxRequest, opts ...grpc.CallOption) (*ListPodSandboxResponse, error) // CreateContainer creates a new container in specified PodSandbox CreateContainer(ctx context.Context, in *CreateContainerRequest, opts ...grpc.CallOption) (*CreateContainerResponse, error) // StartContainer starts the container. StartContainer(ctx context.Context, in *StartContainerRequest, opts ...grpc.CallOption) (*StartContainerResponse, error) // StopContainer stops a running container with a grace period (i.e., timeout). // This call is idempotent, and must not return an error if the container has // already been stopped. // The runtime must forcibly kill the container after the grace period is // reached. StopContainer(ctx context.Context, in *StopContainerRequest, opts ...grpc.CallOption) (*StopContainerResponse, error) // RemoveContainer removes the container. If the container is running, the // container must be forcibly removed. // This call is idempotent, and must not return an error if the container has // already been removed. RemoveContainer(ctx context.Context, in *RemoveContainerRequest, opts ...grpc.CallOption) (*RemoveContainerResponse, error) // ListContainers lists all containers by filters. ListContainers(ctx context.Context, in *ListContainersRequest, opts ...grpc.CallOption) (*ListContainersResponse, error) // ContainerStatus returns status of the container. If the container is not // present, returns an error. ContainerStatus(ctx context.Context, in *ContainerStatusRequest, opts ...grpc.CallOption) (*ContainerStatusResponse, error) // UpdateContainerResources updates ContainerConfig of the container synchronously. // If runtime fails to transactionally update the requested resources, an error is returned. UpdateContainerResources(ctx context.Context, in *UpdateContainerResourcesRequest, opts ...grpc.CallOption) (*UpdateContainerResourcesResponse, error) // ReopenContainerLog asks runtime to reopen the stdout/stderr log file // for the container. This is often called after the log file has been // rotated. If the container is not running, container runtime can choose // to either create a new log file and return nil, or return an error. // Once it returns error, new container log file MUST NOT be created. ReopenContainerLog(ctx context.Context, in *ReopenContainerLogRequest, opts ...grpc.CallOption) (*ReopenContainerLogResponse, error) // ExecSync runs a command in a container synchronously. ExecSync(ctx context.Context, in *ExecSyncRequest, opts ...grpc.CallOption) (*ExecSyncResponse, error) // Exec prepares a streaming endpoint to execute a command in the container. Exec(ctx context.Context, in *ExecRequest, opts ...grpc.CallOption) (*ExecResponse, error) // Attach prepares a streaming endpoint to attach to a running container. Attach(ctx context.Context, in *AttachRequest, opts ...grpc.CallOption) (*AttachResponse, error) // PortForward prepares a streaming endpoint to forward ports from a PodSandbox. PortForward(ctx context.Context, in *PortForwardRequest, opts ...grpc.CallOption) (*PortForwardResponse, error) // ContainerStats returns stats of the container. If the container does not // exist, the call returns an error. ContainerStats(ctx context.Context, in *ContainerStatsRequest, opts ...grpc.CallOption) (*ContainerStatsResponse, error) // ListContainerStats returns stats of all running containers. ListContainerStats(ctx context.Context, in *ListContainerStatsRequest, opts ...grpc.CallOption) (*ListContainerStatsResponse, error) // PodSandboxStats returns stats of the pod sandbox. If the pod sandbox does not // exist, the call returns an error. PodSandboxStats(ctx context.Context, in *PodSandboxStatsRequest, opts ...grpc.CallOption) (*PodSandboxStatsResponse, error) // ListPodSandboxStats returns stats of the pod sandboxes matching a filter. ListPodSandboxStats(ctx context.Context, in *ListPodSandboxStatsRequest, opts ...grpc.CallOption) (*ListPodSandboxStatsResponse, error) // UpdateRuntimeConfig updates the runtime configuration based on the given request. UpdateRuntimeConfig(ctx context.Context, in *UpdateRuntimeConfigRequest, opts ...grpc.CallOption) (*UpdateRuntimeConfigResponse, error) // Status returns the status of the runtime. Status(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (*StatusResponse, error) // CheckpointContainer checkpoints a container CheckpointContainer(ctx context.Context, in *CheckpointContainerRequest, opts ...grpc.CallOption) (*CheckpointContainerResponse, error) // GetContainerEvents gets container events from the CRI runtime GetContainerEvents(ctx context.Context, in *GetEventsRequest, opts ...grpc.CallOption) (RuntimeService_GetContainerEventsClient, error) // 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 // adding or removing metrics descriptors, or they should not change. // Put differently, if ListPodSandboxMetrics references a name that is not described in the initial // ListMetricDescriptors call, then the metric will not be broadcasted. 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 { cc *grpc.ClientConn } func NewRuntimeServiceClient(cc *grpc.ClientConn) RuntimeServiceClient { return &runtimeServiceClient{cc} } func (c *runtimeServiceClient) Version(ctx context.Context, in *VersionRequest, opts ...grpc.CallOption) (*VersionResponse, error) { out := new(VersionResponse) err := c.cc.Invoke(ctx, "/runtime.v1.RuntimeService/Version", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *runtimeServiceClient) RunPodSandbox(ctx context.Context, in *RunPodSandboxRequest, opts ...grpc.CallOption) (*RunPodSandboxResponse, error) { out := new(RunPodSandboxResponse) err := c.cc.Invoke(ctx, "/runtime.v1.RuntimeService/RunPodSandbox", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *runtimeServiceClient) StopPodSandbox(ctx context.Context, in *StopPodSandboxRequest, opts ...grpc.CallOption) (*StopPodSandboxResponse, error) { out := new(StopPodSandboxResponse) err := c.cc.Invoke(ctx, "/runtime.v1.RuntimeService/StopPodSandbox", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *runtimeServiceClient) RemovePodSandbox(ctx context.Context, in *RemovePodSandboxRequest, opts ...grpc.CallOption) (*RemovePodSandboxResponse, error) { out := new(RemovePodSandboxResponse) err := c.cc.Invoke(ctx, "/runtime.v1.RuntimeService/RemovePodSandbox", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *runtimeServiceClient) PodSandboxStatus(ctx context.Context, in *PodSandboxStatusRequest, opts ...grpc.CallOption) (*PodSandboxStatusResponse, error) { out := new(PodSandboxStatusResponse) err := c.cc.Invoke(ctx, "/runtime.v1.RuntimeService/PodSandboxStatus", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *runtimeServiceClient) ListPodSandbox(ctx context.Context, in *ListPodSandboxRequest, opts ...grpc.CallOption) (*ListPodSandboxResponse, error) { out := new(ListPodSandboxResponse) err := c.cc.Invoke(ctx, "/runtime.v1.RuntimeService/ListPodSandbox", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *runtimeServiceClient) CreateContainer(ctx context.Context, in *CreateContainerRequest, opts ...grpc.CallOption) (*CreateContainerResponse, error) { out := new(CreateContainerResponse) err := c.cc.Invoke(ctx, "/runtime.v1.RuntimeService/CreateContainer", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *runtimeServiceClient) StartContainer(ctx context.Context, in *StartContainerRequest, opts ...grpc.CallOption) (*StartContainerResponse, error) { out := new(StartContainerResponse) err := c.cc.Invoke(ctx, "/runtime.v1.RuntimeService/StartContainer", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *runtimeServiceClient) StopContainer(ctx context.Context, in *StopContainerRequest, opts ...grpc.CallOption) (*StopContainerResponse, error) { out := new(StopContainerResponse) err := c.cc.Invoke(ctx, "/runtime.v1.RuntimeService/StopContainer", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *runtimeServiceClient) RemoveContainer(ctx context.Context, in *RemoveContainerRequest, opts ...grpc.CallOption) (*RemoveContainerResponse, error) { out := new(RemoveContainerResponse) err := c.cc.Invoke(ctx, "/runtime.v1.RuntimeService/RemoveContainer", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *runtimeServiceClient) ListContainers(ctx context.Context, in *ListContainersRequest, opts ...grpc.CallOption) (*ListContainersResponse, error) { out := new(ListContainersResponse) err := c.cc.Invoke(ctx, "/runtime.v1.RuntimeService/ListContainers", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *runtimeServiceClient) ContainerStatus(ctx context.Context, in *ContainerStatusRequest, opts ...grpc.CallOption) (*ContainerStatusResponse, error) { out := new(ContainerStatusResponse) err := c.cc.Invoke(ctx, "/runtime.v1.RuntimeService/ContainerStatus", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *runtimeServiceClient) UpdateContainerResources(ctx context.Context, in *UpdateContainerResourcesRequest, opts ...grpc.CallOption) (*UpdateContainerResourcesResponse, error) { out := new(UpdateContainerResourcesResponse) err := c.cc.Invoke(ctx, "/runtime.v1.RuntimeService/UpdateContainerResources", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *runtimeServiceClient) ReopenContainerLog(ctx context.Context, in *ReopenContainerLogRequest, opts ...grpc.CallOption) (*ReopenContainerLogResponse, error) { out := new(ReopenContainerLogResponse) err := c.cc.Invoke(ctx, "/runtime.v1.RuntimeService/ReopenContainerLog", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *runtimeServiceClient) ExecSync(ctx context.Context, in *ExecSyncRequest, opts ...grpc.CallOption) (*ExecSyncResponse, error) { out := new(ExecSyncResponse) err := c.cc.Invoke(ctx, "/runtime.v1.RuntimeService/ExecSync", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *runtimeServiceClient) Exec(ctx context.Context, in *ExecRequest, opts ...grpc.CallOption) (*ExecResponse, error) { out := new(ExecResponse) err := c.cc.Invoke(ctx, "/runtime.v1.RuntimeService/Exec", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *runtimeServiceClient) Attach(ctx context.Context, in *AttachRequest, opts ...grpc.CallOption) (*AttachResponse, error) { out := new(AttachResponse) err := c.cc.Invoke(ctx, "/runtime.v1.RuntimeService/Attach", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *runtimeServiceClient) PortForward(ctx context.Context, in *PortForwardRequest, opts ...grpc.CallOption) (*PortForwardResponse, error) { out := new(PortForwardResponse) err := c.cc.Invoke(ctx, "/runtime.v1.RuntimeService/PortForward", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *runtimeServiceClient) ContainerStats(ctx context.Context, in *ContainerStatsRequest, opts ...grpc.CallOption) (*ContainerStatsResponse, error) { out := new(ContainerStatsResponse) err := c.cc.Invoke(ctx, "/runtime.v1.RuntimeService/ContainerStats", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *runtimeServiceClient) ListContainerStats(ctx context.Context, in *ListContainerStatsRequest, opts ...grpc.CallOption) (*ListContainerStatsResponse, error) { out := new(ListContainerStatsResponse) err := c.cc.Invoke(ctx, "/runtime.v1.RuntimeService/ListContainerStats", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *runtimeServiceClient) PodSandboxStats(ctx context.Context, in *PodSandboxStatsRequest, opts ...grpc.CallOption) (*PodSandboxStatsResponse, error) { out := new(PodSandboxStatsResponse) err := c.cc.Invoke(ctx, "/runtime.v1.RuntimeService/PodSandboxStats", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *runtimeServiceClient) ListPodSandboxStats(ctx context.Context, in *ListPodSandboxStatsRequest, opts ...grpc.CallOption) (*ListPodSandboxStatsResponse, error) { out := new(ListPodSandboxStatsResponse) err := c.cc.Invoke(ctx, "/runtime.v1.RuntimeService/ListPodSandboxStats", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *runtimeServiceClient) UpdateRuntimeConfig(ctx context.Context, in *UpdateRuntimeConfigRequest, opts ...grpc.CallOption) (*UpdateRuntimeConfigResponse, error) { out := new(UpdateRuntimeConfigResponse) err := c.cc.Invoke(ctx, "/runtime.v1.RuntimeService/UpdateRuntimeConfig", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *runtimeServiceClient) Status(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (*StatusResponse, error) { out := new(StatusResponse) err := c.cc.Invoke(ctx, "/runtime.v1.RuntimeService/Status", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *runtimeServiceClient) CheckpointContainer(ctx context.Context, in *CheckpointContainerRequest, opts ...grpc.CallOption) (*CheckpointContainerResponse, error) { out := new(CheckpointContainerResponse) err := c.cc.Invoke(ctx, "/runtime.v1.RuntimeService/CheckpointContainer", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *runtimeServiceClient) GetContainerEvents(ctx context.Context, in *GetEventsRequest, opts ...grpc.CallOption) (RuntimeService_GetContainerEventsClient, error) { stream, err := c.cc.NewStream(ctx, &_RuntimeService_serviceDesc.Streams[0], "/runtime.v1.RuntimeService/GetContainerEvents", opts...) if err != nil { return nil, err } x := &runtimeServiceGetContainerEventsClient{stream} if err := x.ClientStream.SendMsg(in); err != nil { return nil, err } if err := x.ClientStream.CloseSend(); err != nil { return nil, err } return x, nil } type RuntimeService_GetContainerEventsClient interface { Recv() (*ContainerEventResponse, error) grpc.ClientStream } type runtimeServiceGetContainerEventsClient struct { grpc.ClientStream } func (x *runtimeServiceGetContainerEventsClient) Recv() (*ContainerEventResponse, error) { m := new(ContainerEventResponse) if err := x.ClientStream.RecvMsg(m); err != nil { return nil, err } return m, nil } func (c *runtimeServiceClient) ListMetricDescriptors(ctx context.Context, in *ListMetricDescriptorsRequest, opts ...grpc.CallOption) (*ListMetricDescriptorsResponse, error) { out := new(ListMetricDescriptorsResponse) err := c.cc.Invoke(ctx, "/runtime.v1.RuntimeService/ListMetricDescriptors", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *runtimeServiceClient) ListPodSandboxMetrics(ctx context.Context, in *ListPodSandboxMetricsRequest, opts ...grpc.CallOption) (*ListPodSandboxMetricsResponse, error) { out := new(ListPodSandboxMetricsResponse) err := c.cc.Invoke(ctx, "/runtime.v1.RuntimeService/ListPodSandboxMetrics", in, out, opts...) if err != nil { return nil, err } 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. Version(context.Context, *VersionRequest) (*VersionResponse, error) // RunPodSandbox creates and starts a pod-level sandbox. Runtimes must ensure // the sandbox is in the ready state on success. RunPodSandbox(context.Context, *RunPodSandboxRequest) (*RunPodSandboxResponse, error) // StopPodSandbox stops any running process that is part of the sandbox and // reclaims network resources (e.g., IP addresses) allocated to the sandbox. // If there are any running containers in the sandbox, they must be forcibly // terminated. // This call is idempotent, and must not return an error if all relevant // resources have already been reclaimed. kubelet will call StopPodSandbox // at least once before calling RemovePodSandbox. It will also attempt to // reclaim resources eagerly, as soon as a sandbox is not needed. Hence, // multiple StopPodSandbox calls are expected. StopPodSandbox(context.Context, *StopPodSandboxRequest) (*StopPodSandboxResponse, error) // RemovePodSandbox removes the sandbox. If there are any running containers // in the sandbox, they must be forcibly terminated and removed. // This call is idempotent, and must not return an error if the sandbox has // already been removed. RemovePodSandbox(context.Context, *RemovePodSandboxRequest) (*RemovePodSandboxResponse, error) // PodSandboxStatus returns the status of the PodSandbox. If the PodSandbox is not // present, returns an error. PodSandboxStatus(context.Context, *PodSandboxStatusRequest) (*PodSandboxStatusResponse, error) // ListPodSandbox returns a list of PodSandboxes. ListPodSandbox(context.Context, *ListPodSandboxRequest) (*ListPodSandboxResponse, error) // CreateContainer creates a new container in specified PodSandbox CreateContainer(context.Context, *CreateContainerRequest) (*CreateContainerResponse, error) // StartContainer starts the container. StartContainer(context.Context, *StartContainerRequest) (*StartContainerResponse, error) // StopContainer stops a running container with a grace period (i.e., timeout). // This call is idempotent, and must not return an error if the container has // already been stopped. // The runtime must forcibly kill the container after the grace period is // reached. StopContainer(context.Context, *StopContainerRequest) (*StopContainerResponse, error) // RemoveContainer removes the container. If the container is running, the // container must be forcibly removed. // This call is idempotent, and must not return an error if the container has // already been removed. RemoveContainer(context.Context, *RemoveContainerRequest) (*RemoveContainerResponse, error) // ListContainers lists all containers by filters. ListContainers(context.Context, *ListContainersRequest) (*ListContainersResponse, error) // ContainerStatus returns status of the container. If the container is not // present, returns an error. ContainerStatus(context.Context, *ContainerStatusRequest) (*ContainerStatusResponse, error) // UpdateContainerResources updates ContainerConfig of the container synchronously. // If runtime fails to transactionally update the requested resources, an error is returned. UpdateContainerResources(context.Context, *UpdateContainerResourcesRequest) (*UpdateContainerResourcesResponse, error) // ReopenContainerLog asks runtime to reopen the stdout/stderr log file // for the container. This is often called after the log file has been // rotated. If the container is not running, container runtime can choose // to either create a new log file and return nil, or return an error. // Once it returns error, new container log file MUST NOT be created. ReopenContainerLog(context.Context, *ReopenContainerLogRequest) (*ReopenContainerLogResponse, error) // ExecSync runs a command in a container synchronously. ExecSync(context.Context, *ExecSyncRequest) (*ExecSyncResponse, error) // Exec prepares a streaming endpoint to execute a command in the container. Exec(context.Context, *ExecRequest) (*ExecResponse, error) // Attach prepares a streaming endpoint to attach to a running container. Attach(context.Context, *AttachRequest) (*AttachResponse, error) // PortForward prepares a streaming endpoint to forward ports from a PodSandbox. PortForward(context.Context, *PortForwardRequest) (*PortForwardResponse, error) // ContainerStats returns stats of the container. If the container does not // exist, the call returns an error. ContainerStats(context.Context, *ContainerStatsRequest) (*ContainerStatsResponse, error) // ListContainerStats returns stats of all running containers. ListContainerStats(context.Context, *ListContainerStatsRequest) (*ListContainerStatsResponse, error) // PodSandboxStats returns stats of the pod sandbox. If the pod sandbox does not // exist, the call returns an error. PodSandboxStats(context.Context, *PodSandboxStatsRequest) (*PodSandboxStatsResponse, error) // ListPodSandboxStats returns stats of the pod sandboxes matching a filter. ListPodSandboxStats(context.Context, *ListPodSandboxStatsRequest) (*ListPodSandboxStatsResponse, error) // UpdateRuntimeConfig updates the runtime configuration based on the given request. UpdateRuntimeConfig(context.Context, *UpdateRuntimeConfigRequest) (*UpdateRuntimeConfigResponse, error) // Status returns the status of the runtime. Status(context.Context, *StatusRequest) (*StatusResponse, error) // CheckpointContainer checkpoints a container CheckpointContainer(context.Context, *CheckpointContainerRequest) (*CheckpointContainerResponse, error) // GetContainerEvents gets container events from the CRI runtime GetContainerEvents(*GetEventsRequest, RuntimeService_GetContainerEventsServer) error // 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 // adding or removing metrics descriptors, or they should not change. // Put differently, if ListPodSandboxMetrics references a name that is not described in the initial // ListMetricDescriptors call, then the metric will not be broadcasted. 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. type UnimplementedRuntimeServiceServer struct { } func (*UnimplementedRuntimeServiceServer) Version(ctx context.Context, req *VersionRequest) (*VersionResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Version not implemented") } func (*UnimplementedRuntimeServiceServer) RunPodSandbox(ctx context.Context, req *RunPodSandboxRequest) (*RunPodSandboxResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method RunPodSandbox not implemented") } func (*UnimplementedRuntimeServiceServer) StopPodSandbox(ctx context.Context, req *StopPodSandboxRequest) (*StopPodSandboxResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method StopPodSandbox not implemented") } func (*UnimplementedRuntimeServiceServer) RemovePodSandbox(ctx context.Context, req *RemovePodSandboxRequest) (*RemovePodSandboxResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method RemovePodSandbox not implemented") } func (*UnimplementedRuntimeServiceServer) PodSandboxStatus(ctx context.Context, req *PodSandboxStatusRequest) (*PodSandboxStatusResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method PodSandboxStatus not implemented") } func (*UnimplementedRuntimeServiceServer) ListPodSandbox(ctx context.Context, req *ListPodSandboxRequest) (*ListPodSandboxResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ListPodSandbox not implemented") } func (*UnimplementedRuntimeServiceServer) CreateContainer(ctx context.Context, req *CreateContainerRequest) (*CreateContainerResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method CreateContainer not implemented") } func (*UnimplementedRuntimeServiceServer) StartContainer(ctx context.Context, req *StartContainerRequest) (*StartContainerResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method StartContainer not implemented") } func (*UnimplementedRuntimeServiceServer) StopContainer(ctx context.Context, req *StopContainerRequest) (*StopContainerResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method StopContainer not implemented") } func (*UnimplementedRuntimeServiceServer) RemoveContainer(ctx context.Context, req *RemoveContainerRequest) (*RemoveContainerResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method RemoveContainer not implemented") } func (*UnimplementedRuntimeServiceServer) ListContainers(ctx context.Context, req *ListContainersRequest) (*ListContainersResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ListContainers not implemented") } func (*UnimplementedRuntimeServiceServer) ContainerStatus(ctx context.Context, req *ContainerStatusRequest) (*ContainerStatusResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ContainerStatus not implemented") } func (*UnimplementedRuntimeServiceServer) UpdateContainerResources(ctx context.Context, req *UpdateContainerResourcesRequest) (*UpdateContainerResourcesResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method UpdateContainerResources not implemented") } func (*UnimplementedRuntimeServiceServer) ReopenContainerLog(ctx context.Context, req *ReopenContainerLogRequest) (*ReopenContainerLogResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ReopenContainerLog not implemented") } func (*UnimplementedRuntimeServiceServer) ExecSync(ctx context.Context, req *ExecSyncRequest) (*ExecSyncResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ExecSync not implemented") } func (*UnimplementedRuntimeServiceServer) Exec(ctx context.Context, req *ExecRequest) (*ExecResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Exec not implemented") } func (*UnimplementedRuntimeServiceServer) Attach(ctx context.Context, req *AttachRequest) (*AttachResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Attach not implemented") } func (*UnimplementedRuntimeServiceServer) PortForward(ctx context.Context, req *PortForwardRequest) (*PortForwardResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method PortForward not implemented") } func (*UnimplementedRuntimeServiceServer) ContainerStats(ctx context.Context, req *ContainerStatsRequest) (*ContainerStatsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ContainerStats not implemented") } func (*UnimplementedRuntimeServiceServer) ListContainerStats(ctx context.Context, req *ListContainerStatsRequest) (*ListContainerStatsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ListContainerStats not implemented") } func (*UnimplementedRuntimeServiceServer) PodSandboxStats(ctx context.Context, req *PodSandboxStatsRequest) (*PodSandboxStatsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method PodSandboxStats not implemented") } func (*UnimplementedRuntimeServiceServer) ListPodSandboxStats(ctx context.Context, req *ListPodSandboxStatsRequest) (*ListPodSandboxStatsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ListPodSandboxStats not implemented") } func (*UnimplementedRuntimeServiceServer) UpdateRuntimeConfig(ctx context.Context, req *UpdateRuntimeConfigRequest) (*UpdateRuntimeConfigResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method UpdateRuntimeConfig not implemented") } func (*UnimplementedRuntimeServiceServer) Status(ctx context.Context, req *StatusRequest) (*StatusResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method Status not implemented") } func (*UnimplementedRuntimeServiceServer) CheckpointContainer(ctx context.Context, req *CheckpointContainerRequest) (*CheckpointContainerResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method CheckpointContainer not implemented") } func (*UnimplementedRuntimeServiceServer) GetContainerEvents(req *GetEventsRequest, srv RuntimeService_GetContainerEventsServer) error { return status.Errorf(codes.Unimplemented, "method GetContainerEvents not implemented") } func (*UnimplementedRuntimeServiceServer) ListMetricDescriptors(ctx context.Context, req *ListMetricDescriptorsRequest) (*ListMetricDescriptorsResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ListMetricDescriptors not implemented") } 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) } func _RuntimeService_Version_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(VersionRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(RuntimeServiceServer).Version(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.RuntimeService/Version", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RuntimeServiceServer).Version(ctx, req.(*VersionRequest)) } return interceptor(ctx, in, info, handler) } func _RuntimeService_RunPodSandbox_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(RunPodSandboxRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(RuntimeServiceServer).RunPodSandbox(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.RuntimeService/RunPodSandbox", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RuntimeServiceServer).RunPodSandbox(ctx, req.(*RunPodSandboxRequest)) } return interceptor(ctx, in, info, handler) } func _RuntimeService_StopPodSandbox_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(StopPodSandboxRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(RuntimeServiceServer).StopPodSandbox(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.RuntimeService/StopPodSandbox", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RuntimeServiceServer).StopPodSandbox(ctx, req.(*StopPodSandboxRequest)) } return interceptor(ctx, in, info, handler) } func _RuntimeService_RemovePodSandbox_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(RemovePodSandboxRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(RuntimeServiceServer).RemovePodSandbox(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.RuntimeService/RemovePodSandbox", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RuntimeServiceServer).RemovePodSandbox(ctx, req.(*RemovePodSandboxRequest)) } return interceptor(ctx, in, info, handler) } func _RuntimeService_PodSandboxStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(PodSandboxStatusRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(RuntimeServiceServer).PodSandboxStatus(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.RuntimeService/PodSandboxStatus", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RuntimeServiceServer).PodSandboxStatus(ctx, req.(*PodSandboxStatusRequest)) } return interceptor(ctx, in, info, handler) } func _RuntimeService_ListPodSandbox_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ListPodSandboxRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(RuntimeServiceServer).ListPodSandbox(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.RuntimeService/ListPodSandbox", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RuntimeServiceServer).ListPodSandbox(ctx, req.(*ListPodSandboxRequest)) } return interceptor(ctx, in, info, handler) } func _RuntimeService_CreateContainer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(CreateContainerRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(RuntimeServiceServer).CreateContainer(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.RuntimeService/CreateContainer", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RuntimeServiceServer).CreateContainer(ctx, req.(*CreateContainerRequest)) } return interceptor(ctx, in, info, handler) } func _RuntimeService_StartContainer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(StartContainerRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(RuntimeServiceServer).StartContainer(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.RuntimeService/StartContainer", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RuntimeServiceServer).StartContainer(ctx, req.(*StartContainerRequest)) } return interceptor(ctx, in, info, handler) } func _RuntimeService_StopContainer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(StopContainerRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(RuntimeServiceServer).StopContainer(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.RuntimeService/StopContainer", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RuntimeServiceServer).StopContainer(ctx, req.(*StopContainerRequest)) } return interceptor(ctx, in, info, handler) } func _RuntimeService_RemoveContainer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(RemoveContainerRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(RuntimeServiceServer).RemoveContainer(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.RuntimeService/RemoveContainer", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RuntimeServiceServer).RemoveContainer(ctx, req.(*RemoveContainerRequest)) } return interceptor(ctx, in, info, handler) } func _RuntimeService_ListContainers_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ListContainersRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(RuntimeServiceServer).ListContainers(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.RuntimeService/ListContainers", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RuntimeServiceServer).ListContainers(ctx, req.(*ListContainersRequest)) } return interceptor(ctx, in, info, handler) } func _RuntimeService_ContainerStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ContainerStatusRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(RuntimeServiceServer).ContainerStatus(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.RuntimeService/ContainerStatus", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RuntimeServiceServer).ContainerStatus(ctx, req.(*ContainerStatusRequest)) } return interceptor(ctx, in, info, handler) } func _RuntimeService_UpdateContainerResources_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(UpdateContainerResourcesRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(RuntimeServiceServer).UpdateContainerResources(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.RuntimeService/UpdateContainerResources", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RuntimeServiceServer).UpdateContainerResources(ctx, req.(*UpdateContainerResourcesRequest)) } return interceptor(ctx, in, info, handler) } func _RuntimeService_ReopenContainerLog_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ReopenContainerLogRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(RuntimeServiceServer).ReopenContainerLog(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.RuntimeService/ReopenContainerLog", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RuntimeServiceServer).ReopenContainerLog(ctx, req.(*ReopenContainerLogRequest)) } return interceptor(ctx, in, info, handler) } func _RuntimeService_ExecSync_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ExecSyncRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(RuntimeServiceServer).ExecSync(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.RuntimeService/ExecSync", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RuntimeServiceServer).ExecSync(ctx, req.(*ExecSyncRequest)) } return interceptor(ctx, in, info, handler) } func _RuntimeService_Exec_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ExecRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(RuntimeServiceServer).Exec(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.RuntimeService/Exec", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RuntimeServiceServer).Exec(ctx, req.(*ExecRequest)) } return interceptor(ctx, in, info, handler) } func _RuntimeService_Attach_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(AttachRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(RuntimeServiceServer).Attach(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.RuntimeService/Attach", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RuntimeServiceServer).Attach(ctx, req.(*AttachRequest)) } return interceptor(ctx, in, info, handler) } func _RuntimeService_PortForward_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(PortForwardRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(RuntimeServiceServer).PortForward(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.RuntimeService/PortForward", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RuntimeServiceServer).PortForward(ctx, req.(*PortForwardRequest)) } return interceptor(ctx, in, info, handler) } func _RuntimeService_ContainerStats_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ContainerStatsRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(RuntimeServiceServer).ContainerStats(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.RuntimeService/ContainerStats", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RuntimeServiceServer).ContainerStats(ctx, req.(*ContainerStatsRequest)) } return interceptor(ctx, in, info, handler) } func _RuntimeService_ListContainerStats_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ListContainerStatsRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(RuntimeServiceServer).ListContainerStats(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.RuntimeService/ListContainerStats", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RuntimeServiceServer).ListContainerStats(ctx, req.(*ListContainerStatsRequest)) } return interceptor(ctx, in, info, handler) } func _RuntimeService_PodSandboxStats_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(PodSandboxStatsRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(RuntimeServiceServer).PodSandboxStats(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.RuntimeService/PodSandboxStats", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RuntimeServiceServer).PodSandboxStats(ctx, req.(*PodSandboxStatsRequest)) } return interceptor(ctx, in, info, handler) } func _RuntimeService_ListPodSandboxStats_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ListPodSandboxStatsRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(RuntimeServiceServer).ListPodSandboxStats(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.RuntimeService/ListPodSandboxStats", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RuntimeServiceServer).ListPodSandboxStats(ctx, req.(*ListPodSandboxStatsRequest)) } return interceptor(ctx, in, info, handler) } func _RuntimeService_UpdateRuntimeConfig_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(UpdateRuntimeConfigRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(RuntimeServiceServer).UpdateRuntimeConfig(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.RuntimeService/UpdateRuntimeConfig", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RuntimeServiceServer).UpdateRuntimeConfig(ctx, req.(*UpdateRuntimeConfigRequest)) } return interceptor(ctx, in, info, handler) } func _RuntimeService_Status_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(StatusRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(RuntimeServiceServer).Status(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.RuntimeService/Status", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RuntimeServiceServer).Status(ctx, req.(*StatusRequest)) } return interceptor(ctx, in, info, handler) } func _RuntimeService_CheckpointContainer_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(CheckpointContainerRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(RuntimeServiceServer).CheckpointContainer(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.RuntimeService/CheckpointContainer", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RuntimeServiceServer).CheckpointContainer(ctx, req.(*CheckpointContainerRequest)) } return interceptor(ctx, in, info, handler) } func _RuntimeService_GetContainerEvents_Handler(srv interface{}, stream grpc.ServerStream) error { m := new(GetEventsRequest) if err := stream.RecvMsg(m); err != nil { return err } return srv.(RuntimeServiceServer).GetContainerEvents(m, &runtimeServiceGetContainerEventsServer{stream}) } type RuntimeService_GetContainerEventsServer interface { Send(*ContainerEventResponse) error grpc.ServerStream } type runtimeServiceGetContainerEventsServer struct { grpc.ServerStream } func (x *runtimeServiceGetContainerEventsServer) Send(m *ContainerEventResponse) error { return x.ServerStream.SendMsg(m) } func _RuntimeService_ListMetricDescriptors_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ListMetricDescriptorsRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(RuntimeServiceServer).ListMetricDescriptors(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.RuntimeService/ListMetricDescriptors", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RuntimeServiceServer).ListMetricDescriptors(ctx, req.(*ListMetricDescriptorsRequest)) } return interceptor(ctx, in, info, handler) } func _RuntimeService_ListPodSandboxMetrics_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ListPodSandboxMetricsRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(RuntimeServiceServer).ListPodSandboxMetrics(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.RuntimeService/ListPodSandboxMetrics", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(RuntimeServiceServer).ListPodSandboxMetrics(ctx, req.(*ListPodSandboxMetricsRequest)) } 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), Methods: []grpc.MethodDesc{ { MethodName: "Version", Handler: _RuntimeService_Version_Handler, }, { MethodName: "RunPodSandbox", Handler: _RuntimeService_RunPodSandbox_Handler, }, { MethodName: "StopPodSandbox", Handler: _RuntimeService_StopPodSandbox_Handler, }, { MethodName: "RemovePodSandbox", Handler: _RuntimeService_RemovePodSandbox_Handler, }, { MethodName: "PodSandboxStatus", Handler: _RuntimeService_PodSandboxStatus_Handler, }, { MethodName: "ListPodSandbox", Handler: _RuntimeService_ListPodSandbox_Handler, }, { MethodName: "CreateContainer", Handler: _RuntimeService_CreateContainer_Handler, }, { MethodName: "StartContainer", Handler: _RuntimeService_StartContainer_Handler, }, { MethodName: "StopContainer", Handler: _RuntimeService_StopContainer_Handler, }, { MethodName: "RemoveContainer", Handler: _RuntimeService_RemoveContainer_Handler, }, { MethodName: "ListContainers", Handler: _RuntimeService_ListContainers_Handler, }, { MethodName: "ContainerStatus", Handler: _RuntimeService_ContainerStatus_Handler, }, { MethodName: "UpdateContainerResources", Handler: _RuntimeService_UpdateContainerResources_Handler, }, { MethodName: "ReopenContainerLog", Handler: _RuntimeService_ReopenContainerLog_Handler, }, { MethodName: "ExecSync", Handler: _RuntimeService_ExecSync_Handler, }, { MethodName: "Exec", Handler: _RuntimeService_Exec_Handler, }, { MethodName: "Attach", Handler: _RuntimeService_Attach_Handler, }, { MethodName: "PortForward", Handler: _RuntimeService_PortForward_Handler, }, { MethodName: "ContainerStats", Handler: _RuntimeService_ContainerStats_Handler, }, { MethodName: "ListContainerStats", Handler: _RuntimeService_ListContainerStats_Handler, }, { MethodName: "PodSandboxStats", Handler: _RuntimeService_PodSandboxStats_Handler, }, { MethodName: "ListPodSandboxStats", Handler: _RuntimeService_ListPodSandboxStats_Handler, }, { MethodName: "UpdateRuntimeConfig", Handler: _RuntimeService_UpdateRuntimeConfig_Handler, }, { MethodName: "Status", Handler: _RuntimeService_Status_Handler, }, { MethodName: "CheckpointContainer", Handler: _RuntimeService_CheckpointContainer_Handler, }, { MethodName: "ListMetricDescriptors", Handler: _RuntimeService_ListMetricDescriptors_Handler, }, { MethodName: "ListPodSandboxMetrics", Handler: _RuntimeService_ListPodSandboxMetrics_Handler, }, { MethodName: "RuntimeConfig", Handler: _RuntimeService_RuntimeConfig_Handler, }, }, Streams: []grpc.StreamDesc{ { StreamName: "GetContainerEvents", Handler: _RuntimeService_GetContainerEvents_Handler, ServerStreams: true, }, }, Metadata: "api.proto", } // ImageServiceClient is the client API for ImageService service. // // For semantics around ctx use and closing/ending streaming RPCs, please refer to https://godoc.org/google.golang.org/grpc#ClientConn.NewStream. type ImageServiceClient interface { // ListImages lists existing images. ListImages(ctx context.Context, in *ListImagesRequest, opts ...grpc.CallOption) (*ListImagesResponse, error) // ImageStatus returns the status of the image. If the image is not // present, returns a response with ImageStatusResponse.Image set to // nil. ImageStatus(ctx context.Context, in *ImageStatusRequest, opts ...grpc.CallOption) (*ImageStatusResponse, error) // PullImage pulls an image with authentication config. PullImage(ctx context.Context, in *PullImageRequest, opts ...grpc.CallOption) (*PullImageResponse, error) // RemoveImage removes the image. // This call is idempotent, and must not return an error if the image has // already been removed. RemoveImage(ctx context.Context, in *RemoveImageRequest, opts ...grpc.CallOption) (*RemoveImageResponse, error) // ImageFSInfo returns information of the filesystem that is used to store images. ImageFsInfo(ctx context.Context, in *ImageFsInfoRequest, opts ...grpc.CallOption) (*ImageFsInfoResponse, error) } type imageServiceClient struct { cc *grpc.ClientConn } func NewImageServiceClient(cc *grpc.ClientConn) ImageServiceClient { return &imageServiceClient{cc} } func (c *imageServiceClient) ListImages(ctx context.Context, in *ListImagesRequest, opts ...grpc.CallOption) (*ListImagesResponse, error) { out := new(ListImagesResponse) err := c.cc.Invoke(ctx, "/runtime.v1.ImageService/ListImages", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *imageServiceClient) ImageStatus(ctx context.Context, in *ImageStatusRequest, opts ...grpc.CallOption) (*ImageStatusResponse, error) { out := new(ImageStatusResponse) err := c.cc.Invoke(ctx, "/runtime.v1.ImageService/ImageStatus", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *imageServiceClient) PullImage(ctx context.Context, in *PullImageRequest, opts ...grpc.CallOption) (*PullImageResponse, error) { out := new(PullImageResponse) err := c.cc.Invoke(ctx, "/runtime.v1.ImageService/PullImage", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *imageServiceClient) RemoveImage(ctx context.Context, in *RemoveImageRequest, opts ...grpc.CallOption) (*RemoveImageResponse, error) { out := new(RemoveImageResponse) err := c.cc.Invoke(ctx, "/runtime.v1.ImageService/RemoveImage", in, out, opts...) if err != nil { return nil, err } return out, nil } func (c *imageServiceClient) ImageFsInfo(ctx context.Context, in *ImageFsInfoRequest, opts ...grpc.CallOption) (*ImageFsInfoResponse, error) { out := new(ImageFsInfoResponse) err := c.cc.Invoke(ctx, "/runtime.v1.ImageService/ImageFsInfo", in, out, opts...) if err != nil { return nil, err } return out, nil } // ImageServiceServer is the server API for ImageService service. type ImageServiceServer interface { // ListImages lists existing images. ListImages(context.Context, *ListImagesRequest) (*ListImagesResponse, error) // ImageStatus returns the status of the image. If the image is not // present, returns a response with ImageStatusResponse.Image set to // nil. ImageStatus(context.Context, *ImageStatusRequest) (*ImageStatusResponse, error) // PullImage pulls an image with authentication config. PullImage(context.Context, *PullImageRequest) (*PullImageResponse, error) // RemoveImage removes the image. // This call is idempotent, and must not return an error if the image has // already been removed. RemoveImage(context.Context, *RemoveImageRequest) (*RemoveImageResponse, error) // ImageFSInfo returns information of the filesystem that is used to store images. ImageFsInfo(context.Context, *ImageFsInfoRequest) (*ImageFsInfoResponse, error) } // UnimplementedImageServiceServer can be embedded to have forward compatible implementations. type UnimplementedImageServiceServer struct { } func (*UnimplementedImageServiceServer) ListImages(ctx context.Context, req *ListImagesRequest) (*ListImagesResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ListImages not implemented") } func (*UnimplementedImageServiceServer) ImageStatus(ctx context.Context, req *ImageStatusRequest) (*ImageStatusResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ImageStatus not implemented") } func (*UnimplementedImageServiceServer) PullImage(ctx context.Context, req *PullImageRequest) (*PullImageResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method PullImage not implemented") } func (*UnimplementedImageServiceServer) RemoveImage(ctx context.Context, req *RemoveImageRequest) (*RemoveImageResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method RemoveImage not implemented") } func (*UnimplementedImageServiceServer) ImageFsInfo(ctx context.Context, req *ImageFsInfoRequest) (*ImageFsInfoResponse, error) { return nil, status.Errorf(codes.Unimplemented, "method ImageFsInfo not implemented") } func RegisterImageServiceServer(s *grpc.Server, srv ImageServiceServer) { s.RegisterService(&_ImageService_serviceDesc, srv) } func _ImageService_ListImages_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ListImagesRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ImageServiceServer).ListImages(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.ImageService/ListImages", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ImageServiceServer).ListImages(ctx, req.(*ListImagesRequest)) } return interceptor(ctx, in, info, handler) } func _ImageService_ImageStatus_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ImageStatusRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ImageServiceServer).ImageStatus(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.ImageService/ImageStatus", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ImageServiceServer).ImageStatus(ctx, req.(*ImageStatusRequest)) } return interceptor(ctx, in, info, handler) } func _ImageService_PullImage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(PullImageRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ImageServiceServer).PullImage(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.ImageService/PullImage", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ImageServiceServer).PullImage(ctx, req.(*PullImageRequest)) } return interceptor(ctx, in, info, handler) } func _ImageService_RemoveImage_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(RemoveImageRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ImageServiceServer).RemoveImage(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.ImageService/RemoveImage", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ImageServiceServer).RemoveImage(ctx, req.(*RemoveImageRequest)) } return interceptor(ctx, in, info, handler) } func _ImageService_ImageFsInfo_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) { in := new(ImageFsInfoRequest) if err := dec(in); err != nil { return nil, err } if interceptor == nil { return srv.(ImageServiceServer).ImageFsInfo(ctx, in) } info := &grpc.UnaryServerInfo{ Server: srv, FullMethod: "/runtime.v1.ImageService/ImageFsInfo", } handler := func(ctx context.Context, req interface{}) (interface{}, error) { return srv.(ImageServiceServer).ImageFsInfo(ctx, req.(*ImageFsInfoRequest)) } return interceptor(ctx, in, info, handler) } var _ImageService_serviceDesc = grpc.ServiceDesc{ ServiceName: "runtime.v1.ImageService", HandlerType: (*ImageServiceServer)(nil), Methods: []grpc.MethodDesc{ { MethodName: "ListImages", Handler: _ImageService_ListImages_Handler, }, { MethodName: "ImageStatus", Handler: _ImageService_ImageStatus_Handler, }, { MethodName: "PullImage", Handler: _ImageService_PullImage_Handler, }, { MethodName: "RemoveImage", Handler: _ImageService_RemoveImage_Handler, }, { MethodName: "ImageFsInfo", Handler: _ImageService_ImageFsInfo_Handler, }, }, Streams: []grpc.StreamDesc{}, Metadata: "api.proto", } func (m *VersionRequest) 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 *VersionRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *VersionRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Version) > 0 { i -= len(m.Version) copy(dAtA[i:], m.Version) i = encodeVarintApi(dAtA, i, uint64(len(m.Version))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *VersionResponse) 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 *VersionResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *VersionResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.RuntimeApiVersion) > 0 { i -= len(m.RuntimeApiVersion) copy(dAtA[i:], m.RuntimeApiVersion) i = encodeVarintApi(dAtA, i, uint64(len(m.RuntimeApiVersion))) i-- dAtA[i] = 0x22 } if len(m.RuntimeVersion) > 0 { i -= len(m.RuntimeVersion) copy(dAtA[i:], m.RuntimeVersion) i = encodeVarintApi(dAtA, i, uint64(len(m.RuntimeVersion))) i-- dAtA[i] = 0x1a } if len(m.RuntimeName) > 0 { i -= len(m.RuntimeName) copy(dAtA[i:], m.RuntimeName) i = encodeVarintApi(dAtA, i, uint64(len(m.RuntimeName))) i-- dAtA[i] = 0x12 } if len(m.Version) > 0 { i -= len(m.Version) copy(dAtA[i:], m.Version) i = encodeVarintApi(dAtA, i, uint64(len(m.Version))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *DNSConfig) 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 *DNSConfig) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *DNSConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Options) > 0 { for iNdEx := len(m.Options) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.Options[iNdEx]) copy(dAtA[i:], m.Options[iNdEx]) i = encodeVarintApi(dAtA, i, uint64(len(m.Options[iNdEx]))) i-- dAtA[i] = 0x1a } } if len(m.Searches) > 0 { for iNdEx := len(m.Searches) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.Searches[iNdEx]) copy(dAtA[i:], m.Searches[iNdEx]) i = encodeVarintApi(dAtA, i, uint64(len(m.Searches[iNdEx]))) i-- dAtA[i] = 0x12 } } if len(m.Servers) > 0 { for iNdEx := len(m.Servers) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.Servers[iNdEx]) copy(dAtA[i:], m.Servers[iNdEx]) i = encodeVarintApi(dAtA, i, uint64(len(m.Servers[iNdEx]))) i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *PortMapping) 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 *PortMapping) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *PortMapping) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.HostIp) > 0 { i -= len(m.HostIp) copy(dAtA[i:], m.HostIp) i = encodeVarintApi(dAtA, i, uint64(len(m.HostIp))) i-- dAtA[i] = 0x22 } if m.HostPort != 0 { i = encodeVarintApi(dAtA, i, uint64(m.HostPort)) i-- dAtA[i] = 0x18 } if m.ContainerPort != 0 { i = encodeVarintApi(dAtA, i, uint64(m.ContainerPort)) i-- dAtA[i] = 0x10 } if m.Protocol != 0 { i = encodeVarintApi(dAtA, i, uint64(m.Protocol)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } func (m *Mount) 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 *Mount) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *Mount) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = 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-- { { size, err := m.GidMappings[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x3a } } if len(m.UidMappings) > 0 { for iNdEx := len(m.UidMappings) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.UidMappings[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x32 } } if m.Propagation != 0 { i = encodeVarintApi(dAtA, i, uint64(m.Propagation)) i-- dAtA[i] = 0x28 } if m.SelinuxRelabel { i-- if m.SelinuxRelabel { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x20 } if m.Readonly { i-- if m.Readonly { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x18 } if len(m.HostPath) > 0 { i -= len(m.HostPath) copy(dAtA[i:], m.HostPath) i = encodeVarintApi(dAtA, i, uint64(len(m.HostPath))) i-- dAtA[i] = 0x12 } if len(m.ContainerPath) > 0 { i -= len(m.ContainerPath) copy(dAtA[i:], m.ContainerPath) i = encodeVarintApi(dAtA, i, uint64(len(m.ContainerPath))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *IDMapping) 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 *IDMapping) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *IDMapping) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Length != 0 { i = encodeVarintApi(dAtA, i, uint64(m.Length)) i-- dAtA[i] = 0x18 } if m.ContainerId != 0 { i = encodeVarintApi(dAtA, i, uint64(m.ContainerId)) i-- dAtA[i] = 0x10 } if m.HostId != 0 { i = encodeVarintApi(dAtA, i, uint64(m.HostId)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } func (m *UserNamespace) 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 *UserNamespace) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *UserNamespace) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Gids) > 0 { for iNdEx := len(m.Gids) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Gids[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.Uids) > 0 { for iNdEx := len(m.Uids) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Uids[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } } if m.Mode != 0 { i = encodeVarintApi(dAtA, i, uint64(m.Mode)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } func (m *NamespaceOption) 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 *NamespaceOption) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *NamespaceOption) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.UsernsOptions != nil { { size, err := m.UsernsOptions.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x2a } if len(m.TargetId) > 0 { i -= len(m.TargetId) copy(dAtA[i:], m.TargetId) i = encodeVarintApi(dAtA, i, uint64(len(m.TargetId))) i-- dAtA[i] = 0x22 } if m.Ipc != 0 { i = encodeVarintApi(dAtA, i, uint64(m.Ipc)) i-- dAtA[i] = 0x18 } if m.Pid != 0 { i = encodeVarintApi(dAtA, i, uint64(m.Pid)) i-- dAtA[i] = 0x10 } if m.Network != 0 { i = encodeVarintApi(dAtA, i, uint64(m.Network)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } func (m *Int64Value) 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 *Int64Value) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *Int64Value) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Value != 0 { i = encodeVarintApi(dAtA, i, uint64(m.Value)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } func (m *LinuxSandboxSecurityContext) 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 *LinuxSandboxSecurityContext) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *LinuxSandboxSecurityContext) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = 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]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x52 } if m.Seccomp != nil { { size, err := m.Seccomp.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x4a } if m.RunAsGroup != nil { { size, err := m.RunAsGroup.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x42 } if len(m.SeccompProfilePath) > 0 { i -= len(m.SeccompProfilePath) copy(dAtA[i:], m.SeccompProfilePath) i = encodeVarintApi(dAtA, i, uint64(len(m.SeccompProfilePath))) i-- dAtA[i] = 0x3a } if m.Privileged { i-- if m.Privileged { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x30 } if len(m.SupplementalGroups) > 0 { dAtA7 := make([]byte, len(m.SupplementalGroups)*10) var j6 int for _, num1 := range m.SupplementalGroups { num := uint64(num1) for num >= 1<<7 { dAtA7[j6] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j6++ } dAtA7[j6] = uint8(num) j6++ } i -= j6 copy(dAtA[i:], dAtA7[:j6]) i = encodeVarintApi(dAtA, i, uint64(j6)) i-- dAtA[i] = 0x2a } if m.ReadonlyRootfs { i-- if m.ReadonlyRootfs { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x20 } if m.RunAsUser != nil { { size, err := m.RunAsUser.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1a } if m.SelinuxOptions != nil { { size, err := m.SelinuxOptions.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } if m.NamespaceOptions != nil { { size, err := m.NamespaceOptions.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 *SecurityProfile) 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 *SecurityProfile) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *SecurityProfile) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.LocalhostRef) > 0 { i -= len(m.LocalhostRef) copy(dAtA[i:], m.LocalhostRef) i = encodeVarintApi(dAtA, i, uint64(len(m.LocalhostRef))) i-- dAtA[i] = 0x12 } if m.ProfileType != 0 { i = encodeVarintApi(dAtA, i, uint64(m.ProfileType)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } func (m *LinuxPodSandboxConfig) 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 *LinuxPodSandboxConfig) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *LinuxPodSandboxConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Resources != nil { { size, err := m.Resources.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x2a } if m.Overhead != nil { { size, err := m.Overhead.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x22 } if len(m.Sysctls) > 0 { for k := range m.Sysctls { v := m.Sysctls[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintApi(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintApi(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintApi(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x1a } } if m.SecurityContext != nil { { size, err := m.SecurityContext.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } if len(m.CgroupParent) > 0 { i -= len(m.CgroupParent) copy(dAtA[i:], m.CgroupParent) i = encodeVarintApi(dAtA, i, uint64(len(m.CgroupParent))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *PodSandboxMetadata) 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 *PodSandboxMetadata) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *PodSandboxMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Attempt != 0 { i = encodeVarintApi(dAtA, i, uint64(m.Attempt)) i-- dAtA[i] = 0x20 } if len(m.Namespace) > 0 { i -= len(m.Namespace) copy(dAtA[i:], m.Namespace) i = encodeVarintApi(dAtA, i, uint64(len(m.Namespace))) i-- dAtA[i] = 0x1a } if len(m.Uid) > 0 { i -= len(m.Uid) copy(dAtA[i:], m.Uid) i = encodeVarintApi(dAtA, i, uint64(len(m.Uid))) 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 *PodSandboxConfig) 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 *PodSandboxConfig) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *PodSandboxConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Windows != nil { { size, err := m.Windows.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x4a } 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] = 0x42 } if len(m.Annotations) > 0 { for k := range m.Annotations { v := m.Annotations[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintApi(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintApi(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintApi(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x3a } } if len(m.Labels) > 0 { for k := range m.Labels { v := m.Labels[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintApi(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintApi(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintApi(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x32 } } if len(m.PortMappings) > 0 { for iNdEx := len(m.PortMappings) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.PortMappings[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x2a } } if m.DnsConfig != nil { { size, err := m.DnsConfig.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x22 } if len(m.LogDirectory) > 0 { i -= len(m.LogDirectory) copy(dAtA[i:], m.LogDirectory) i = encodeVarintApi(dAtA, i, uint64(len(m.LogDirectory))) i-- dAtA[i] = 0x1a } if len(m.Hostname) > 0 { i -= len(m.Hostname) copy(dAtA[i:], m.Hostname) i = encodeVarintApi(dAtA, i, uint64(len(m.Hostname))) i-- dAtA[i] = 0x12 } if m.Metadata != nil { { size, err := m.Metadata.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 *RunPodSandboxRequest) 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 *RunPodSandboxRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *RunPodSandboxRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = 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] = 0x12 } if m.Config != nil { { size, err := m.Config.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 *RunPodSandboxResponse) 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 *RunPodSandboxResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *RunPodSandboxResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.PodSandboxId) > 0 { i -= len(m.PodSandboxId) copy(dAtA[i:], m.PodSandboxId) i = encodeVarintApi(dAtA, i, uint64(len(m.PodSandboxId))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *StopPodSandboxRequest) 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 *StopPodSandboxRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *StopPodSandboxRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.PodSandboxId) > 0 { i -= len(m.PodSandboxId) copy(dAtA[i:], m.PodSandboxId) i = encodeVarintApi(dAtA, i, uint64(len(m.PodSandboxId))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *StopPodSandboxResponse) 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 *StopPodSandboxResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *StopPodSandboxResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l return len(dAtA) - i, nil } func (m *RemovePodSandboxRequest) 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 *RemovePodSandboxRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *RemovePodSandboxRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.PodSandboxId) > 0 { i -= len(m.PodSandboxId) copy(dAtA[i:], m.PodSandboxId) i = encodeVarintApi(dAtA, i, uint64(len(m.PodSandboxId))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *RemovePodSandboxResponse) 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 *RemovePodSandboxResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *RemovePodSandboxResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l return len(dAtA) - i, nil } func (m *PodSandboxStatusRequest) 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 *PodSandboxStatusRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *PodSandboxStatusRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Verbose { i-- if m.Verbose { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x10 } if len(m.PodSandboxId) > 0 { i -= len(m.PodSandboxId) copy(dAtA[i:], m.PodSandboxId) i = encodeVarintApi(dAtA, i, uint64(len(m.PodSandboxId))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *PodIP) 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 *PodIP) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *PodIP) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Ip) > 0 { i -= len(m.Ip) copy(dAtA[i:], m.Ip) i = encodeVarintApi(dAtA, i, uint64(len(m.Ip))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *PodSandboxNetworkStatus) 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 *PodSandboxNetworkStatus) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *PodSandboxNetworkStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.AdditionalIps) > 0 { for iNdEx := len(m.AdditionalIps) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.AdditionalIps[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.Ip) > 0 { i -= len(m.Ip) copy(dAtA[i:], m.Ip) i = encodeVarintApi(dAtA, i, uint64(len(m.Ip))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *Namespace) 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 *Namespace) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *Namespace) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Options != nil { { size, err := m.Options.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } return len(dAtA) - i, nil } func (m *LinuxPodSandboxStatus) 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 *LinuxPodSandboxStatus) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *LinuxPodSandboxStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Namespaces != nil { { size, err := m.Namespaces.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 *PodSandboxStatus) 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 *PodSandboxStatus) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *PodSandboxStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = 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] = 0x4a } if len(m.Annotations) > 0 { for k := range m.Annotations { v := m.Annotations[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintApi(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintApi(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintApi(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x42 } } if len(m.Labels) > 0 { for k := range m.Labels { v := m.Labels[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintApi(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintApi(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintApi(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x3a } } 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] = 0x32 } if m.Network != nil { { size, err := m.Network.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x2a } if m.CreatedAt != 0 { i = encodeVarintApi(dAtA, i, uint64(m.CreatedAt)) i-- dAtA[i] = 0x20 } if m.State != 0 { i = encodeVarintApi(dAtA, i, uint64(m.State)) i-- dAtA[i] = 0x18 } if m.Metadata != nil { { size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } if len(m.Id) > 0 { i -= len(m.Id) copy(dAtA[i:], m.Id) i = encodeVarintApi(dAtA, i, uint64(len(m.Id))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *PodSandboxStatusResponse) 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 *PodSandboxStatusResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *PodSandboxStatusResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Timestamp != 0 { i = encodeVarintApi(dAtA, i, uint64(m.Timestamp)) i-- dAtA[i] = 0x20 } if len(m.ContainersStatuses) > 0 { for iNdEx := len(m.ContainersStatuses) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.ContainersStatuses[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] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintApi(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintApi(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintApi(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x12 } } if m.Status != nil { { size, err := m.Status.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 *PodSandboxStateValue) 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 *PodSandboxStateValue) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *PodSandboxStateValue) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.State != 0 { i = encodeVarintApi(dAtA, i, uint64(m.State)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } func (m *PodSandboxFilter) 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 *PodSandboxFilter) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *PodSandboxFilter) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.LabelSelector) > 0 { for k := range m.LabelSelector { v := m.LabelSelector[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintApi(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintApi(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintApi(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x1a } } if m.State != nil { { size, err := m.State.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } if len(m.Id) > 0 { i -= len(m.Id) copy(dAtA[i:], m.Id) i = encodeVarintApi(dAtA, i, uint64(len(m.Id))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ListPodSandboxRequest) 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 *ListPodSandboxRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListPodSandboxRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Filter != nil { { size, err := m.Filter.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 *PodSandbox) 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 *PodSandbox) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *PodSandbox) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = 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] = 0x3a } if len(m.Annotations) > 0 { for k := range m.Annotations { v := m.Annotations[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintApi(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintApi(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintApi(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x32 } } if len(m.Labels) > 0 { for k := range m.Labels { v := m.Labels[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintApi(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintApi(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintApi(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x2a } } if m.CreatedAt != 0 { i = encodeVarintApi(dAtA, i, uint64(m.CreatedAt)) i-- dAtA[i] = 0x20 } if m.State != 0 { i = encodeVarintApi(dAtA, i, uint64(m.State)) i-- dAtA[i] = 0x18 } if m.Metadata != nil { { size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } if len(m.Id) > 0 { i -= len(m.Id) copy(dAtA[i:], m.Id) i = encodeVarintApi(dAtA, i, uint64(len(m.Id))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ListPodSandboxResponse) 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 *ListPodSandboxResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListPodSandboxResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Items) > 0 { for iNdEx := len(m.Items) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Items[iNdEx].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 *PodSandboxStatsRequest) 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 *PodSandboxStatsRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *PodSandboxStatsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.PodSandboxId) > 0 { i -= len(m.PodSandboxId) copy(dAtA[i:], m.PodSandboxId) i = encodeVarintApi(dAtA, i, uint64(len(m.PodSandboxId))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *PodSandboxStatsResponse) 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 *PodSandboxStatsResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *PodSandboxStatsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Stats != nil { { size, err := m.Stats.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 *PodSandboxStatsFilter) 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 *PodSandboxStatsFilter) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *PodSandboxStatsFilter) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.LabelSelector) > 0 { for k := range m.LabelSelector { v := m.LabelSelector[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintApi(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintApi(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintApi(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x12 } } if len(m.Id) > 0 { i -= len(m.Id) copy(dAtA[i:], m.Id) i = encodeVarintApi(dAtA, i, uint64(len(m.Id))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ListPodSandboxStatsRequest) 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 *ListPodSandboxStatsRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListPodSandboxStatsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Filter != nil { { size, err := m.Filter.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 *ListPodSandboxStatsResponse) 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 *ListPodSandboxStatsResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListPodSandboxStatsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Stats) > 0 { for iNdEx := len(m.Stats) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Stats[iNdEx].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 *PodSandboxAttributes) 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 *PodSandboxAttributes) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *PodSandboxAttributes) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Annotations) > 0 { for k := range m.Annotations { v := m.Annotations[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintApi(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintApi(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintApi(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x22 } } if len(m.Labels) > 0 { for k := range m.Labels { v := m.Labels[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintApi(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintApi(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintApi(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x1a } } if m.Metadata != nil { { size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } if len(m.Id) > 0 { i -= len(m.Id) copy(dAtA[i:], m.Id) i = encodeVarintApi(dAtA, i, uint64(len(m.Id))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *PodSandboxStats) 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 *PodSandboxStats) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *PodSandboxStats) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Windows != nil { { size, err := m.Windows.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1a } 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] = 0x12 } if m.Attributes != nil { { size, err := m.Attributes.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 *LinuxPodSandboxStats) 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 *LinuxPodSandboxStats) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *LinuxPodSandboxStats) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Containers) > 0 { for iNdEx := len(m.Containers) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Containers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x2a } } if m.Process != nil { { size, err := m.Process.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x22 } if m.Network != nil { { size, err := m.Network.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1a } if m.Memory != nil { { size, err := m.Memory.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } if m.Cpu != nil { { size, err := m.Cpu.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 *WindowsPodSandboxStats) 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 *WindowsPodSandboxStats) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *WindowsPodSandboxStats) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Containers) > 0 { for iNdEx := len(m.Containers) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Containers[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x2a } } if m.Process != nil { { size, err := m.Process.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x22 } if m.Network != nil { { size, err := m.Network.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1a } if m.Memory != nil { { size, err := m.Memory.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } if m.Cpu != nil { { size, err := m.Cpu.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 *NetworkUsage) 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 *NetworkUsage) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *NetworkUsage) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Interfaces) > 0 { for iNdEx := len(m.Interfaces) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Interfaces[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1a } } if m.DefaultInterface != nil { { size, err := m.DefaultInterface.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 *WindowsNetworkUsage) 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 *WindowsNetworkUsage) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *WindowsNetworkUsage) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Interfaces) > 0 { for iNdEx := len(m.Interfaces) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Interfaces[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1a } } if m.DefaultInterface != nil { { size, err := m.DefaultInterface.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 *NetworkInterfaceUsage) 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 *NetworkInterfaceUsage) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *NetworkInterfaceUsage) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.TxErrors != nil { { size, err := m.TxErrors.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x2a } if m.TxBytes != nil { { size, err := m.TxBytes.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x22 } if m.RxErrors != nil { { size, err := m.RxErrors.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1a } if m.RxBytes != nil { { size, err := m.RxBytes.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 *WindowsNetworkInterfaceUsage) 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 *WindowsNetworkInterfaceUsage) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *WindowsNetworkInterfaceUsage) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.TxPacketsDropped != nil { { size, err := m.TxPacketsDropped.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x2a } if m.TxBytes != nil { { size, err := m.TxBytes.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x22 } if m.RxPacketsDropped != nil { { size, err := m.RxPacketsDropped.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1a } if m.RxBytes != nil { { size, err := m.RxBytes.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 *ProcessUsage) 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 *ProcessUsage) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ProcessUsage) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.ProcessCount != nil { { size, err := m.ProcessCount.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 *WindowsProcessUsage) 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 *WindowsProcessUsage) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *WindowsProcessUsage) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.ProcessCount != nil { { size, err := m.ProcessCount.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 *ImageSpec) 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 *ImageSpec) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ImageSpec) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = 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] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintApi(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintApi(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintApi(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x12 } } if len(m.Image) > 0 { i -= len(m.Image) copy(dAtA[i:], m.Image) i = encodeVarintApi(dAtA, i, uint64(len(m.Image))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *KeyValue) 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 *KeyValue) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *KeyValue) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Value) > 0 { i -= len(m.Value) copy(dAtA[i:], m.Value) i = encodeVarintApi(dAtA, i, uint64(len(m.Value))) i-- dAtA[i] = 0x12 } if len(m.Key) > 0 { i -= len(m.Key) copy(dAtA[i:], m.Key) i = encodeVarintApi(dAtA, i, uint64(len(m.Key))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *LinuxContainerResources) 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 *LinuxContainerResources) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *LinuxContainerResources) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.MemorySwapLimitInBytes != 0 { i = encodeVarintApi(dAtA, i, uint64(m.MemorySwapLimitInBytes)) i-- dAtA[i] = 0x50 } if len(m.Unified) > 0 { for k := range m.Unified { v := m.Unified[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintApi(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintApi(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintApi(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x4a } } if len(m.HugepageLimits) > 0 { for iNdEx := len(m.HugepageLimits) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.HugepageLimits[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x42 } } if len(m.CpusetMems) > 0 { i -= len(m.CpusetMems) copy(dAtA[i:], m.CpusetMems) i = encodeVarintApi(dAtA, i, uint64(len(m.CpusetMems))) i-- dAtA[i] = 0x3a } if len(m.CpusetCpus) > 0 { i -= len(m.CpusetCpus) copy(dAtA[i:], m.CpusetCpus) i = encodeVarintApi(dAtA, i, uint64(len(m.CpusetCpus))) i-- dAtA[i] = 0x32 } if m.OomScoreAdj != 0 { i = encodeVarintApi(dAtA, i, uint64(m.OomScoreAdj)) i-- dAtA[i] = 0x28 } if m.MemoryLimitInBytes != 0 { i = encodeVarintApi(dAtA, i, uint64(m.MemoryLimitInBytes)) i-- dAtA[i] = 0x20 } if m.CpuShares != 0 { i = encodeVarintApi(dAtA, i, uint64(m.CpuShares)) i-- dAtA[i] = 0x18 } if m.CpuQuota != 0 { i = encodeVarintApi(dAtA, i, uint64(m.CpuQuota)) i-- dAtA[i] = 0x10 } if m.CpuPeriod != 0 { i = encodeVarintApi(dAtA, i, uint64(m.CpuPeriod)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } func (m *HugepageLimit) 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 *HugepageLimit) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *HugepageLimit) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Limit != 0 { i = encodeVarintApi(dAtA, i, uint64(m.Limit)) i-- dAtA[i] = 0x10 } if len(m.PageSize) > 0 { i -= len(m.PageSize) copy(dAtA[i:], m.PageSize) i = encodeVarintApi(dAtA, i, uint64(len(m.PageSize))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *SELinuxOption) 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 *SELinuxOption) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *SELinuxOption) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Level) > 0 { i -= len(m.Level) copy(dAtA[i:], m.Level) i = encodeVarintApi(dAtA, i, uint64(len(m.Level))) i-- dAtA[i] = 0x22 } if len(m.Type) > 0 { i -= len(m.Type) copy(dAtA[i:], m.Type) i = encodeVarintApi(dAtA, i, uint64(len(m.Type))) i-- dAtA[i] = 0x1a } if len(m.Role) > 0 { i -= len(m.Role) copy(dAtA[i:], m.Role) i = encodeVarintApi(dAtA, i, uint64(len(m.Role))) i-- dAtA[i] = 0x12 } if len(m.User) > 0 { i -= len(m.User) copy(dAtA[i:], m.User) i = encodeVarintApi(dAtA, i, uint64(len(m.User))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *Capability) 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 *Capability) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *Capability) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.AddAmbientCapabilities) > 0 { for iNdEx := len(m.AddAmbientCapabilities) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.AddAmbientCapabilities[iNdEx]) copy(dAtA[i:], m.AddAmbientCapabilities[iNdEx]) i = encodeVarintApi(dAtA, i, uint64(len(m.AddAmbientCapabilities[iNdEx]))) i-- dAtA[i] = 0x1a } } if len(m.DropCapabilities) > 0 { for iNdEx := len(m.DropCapabilities) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.DropCapabilities[iNdEx]) copy(dAtA[i:], m.DropCapabilities[iNdEx]) i = encodeVarintApi(dAtA, i, uint64(len(m.DropCapabilities[iNdEx]))) i-- dAtA[i] = 0x12 } } if len(m.AddCapabilities) > 0 { for iNdEx := len(m.AddCapabilities) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.AddCapabilities[iNdEx]) copy(dAtA[i:], m.AddCapabilities[iNdEx]) i = encodeVarintApi(dAtA, i, uint64(len(m.AddCapabilities[iNdEx]))) i-- dAtA[i] = 0xa } } return len(dAtA) - i, nil } func (m *LinuxContainerSecurityContext) 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 *LinuxContainerSecurityContext) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *LinuxContainerSecurityContext) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = 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]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1 i-- dAtA[i] = 0x82 } if m.Seccomp != nil { { size, err := m.Seccomp.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x7a } if len(m.ReadonlyPaths) > 0 { for iNdEx := len(m.ReadonlyPaths) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.ReadonlyPaths[iNdEx]) copy(dAtA[i:], m.ReadonlyPaths[iNdEx]) i = encodeVarintApi(dAtA, i, uint64(len(m.ReadonlyPaths[iNdEx]))) i-- dAtA[i] = 0x72 } } if len(m.MaskedPaths) > 0 { for iNdEx := len(m.MaskedPaths) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.MaskedPaths[iNdEx]) copy(dAtA[i:], m.MaskedPaths[iNdEx]) i = encodeVarintApi(dAtA, i, uint64(len(m.MaskedPaths[iNdEx]))) i-- dAtA[i] = 0x6a } } if m.RunAsGroup != nil { { size, err := m.RunAsGroup.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x62 } if m.NoNewPrivs { i-- if m.NoNewPrivs { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x58 } if len(m.SeccompProfilePath) > 0 { i -= len(m.SeccompProfilePath) copy(dAtA[i:], m.SeccompProfilePath) i = encodeVarintApi(dAtA, i, uint64(len(m.SeccompProfilePath))) i-- dAtA[i] = 0x52 } if len(m.ApparmorProfile) > 0 { i -= len(m.ApparmorProfile) copy(dAtA[i:], m.ApparmorProfile) i = encodeVarintApi(dAtA, i, uint64(len(m.ApparmorProfile))) i-- dAtA[i] = 0x4a } if len(m.SupplementalGroups) > 0 { dAtA58 := make([]byte, len(m.SupplementalGroups)*10) var j57 int for _, num1 := range m.SupplementalGroups { num := uint64(num1) for num >= 1<<7 { dAtA58[j57] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j57++ } dAtA58[j57] = uint8(num) j57++ } i -= j57 copy(dAtA[i:], dAtA58[:j57]) i = encodeVarintApi(dAtA, i, uint64(j57)) i-- dAtA[i] = 0x42 } if m.ReadonlyRootfs { i-- if m.ReadonlyRootfs { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x38 } if len(m.RunAsUsername) > 0 { i -= len(m.RunAsUsername) copy(dAtA[i:], m.RunAsUsername) i = encodeVarintApi(dAtA, i, uint64(len(m.RunAsUsername))) i-- dAtA[i] = 0x32 } if m.RunAsUser != nil { { size, err := m.RunAsUser.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x2a } if m.SelinuxOptions != nil { { size, err := m.SelinuxOptions.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x22 } if m.NamespaceOptions != nil { { size, err := m.NamespaceOptions.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1a } if m.Privileged { i-- if m.Privileged { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x10 } if m.Capabilities != nil { { size, err := m.Capabilities.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 *LinuxContainerConfig) 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 *LinuxContainerConfig) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *LinuxContainerConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.SecurityContext != nil { { size, err := m.SecurityContext.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } if m.Resources != nil { { size, err := m.Resources.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 *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) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *WindowsNamespaceOption) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *WindowsNamespaceOption) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Network != 0 { i = encodeVarintApi(dAtA, i, uint64(m.Network)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } func (m *WindowsSandboxSecurityContext) 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 *WindowsSandboxSecurityContext) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *WindowsSandboxSecurityContext) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.NamespaceOptions != nil { { size, err := m.NamespaceOptions.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x22 } if m.HostProcess { i-- if m.HostProcess { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x18 } if len(m.CredentialSpec) > 0 { i -= len(m.CredentialSpec) copy(dAtA[i:], m.CredentialSpec) i = encodeVarintApi(dAtA, i, uint64(len(m.CredentialSpec))) i-- dAtA[i] = 0x12 } if len(m.RunAsUsername) > 0 { i -= len(m.RunAsUsername) copy(dAtA[i:], m.RunAsUsername) i = encodeVarintApi(dAtA, i, uint64(len(m.RunAsUsername))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *WindowsPodSandboxConfig) 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 *WindowsPodSandboxConfig) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *WindowsPodSandboxConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.SecurityContext != nil { { size, err := m.SecurityContext.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 *WindowsContainerSecurityContext) 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 *WindowsContainerSecurityContext) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *WindowsContainerSecurityContext) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.HostProcess { i-- if m.HostProcess { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x18 } if len(m.CredentialSpec) > 0 { i -= len(m.CredentialSpec) copy(dAtA[i:], m.CredentialSpec) i = encodeVarintApi(dAtA, i, uint64(len(m.CredentialSpec))) i-- dAtA[i] = 0x12 } if len(m.RunAsUsername) > 0 { i -= len(m.RunAsUsername) copy(dAtA[i:], m.RunAsUsername) i = encodeVarintApi(dAtA, i, uint64(len(m.RunAsUsername))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *WindowsContainerConfig) 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 *WindowsContainerConfig) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *WindowsContainerConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.SecurityContext != nil { { size, err := m.SecurityContext.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } if m.Resources != nil { { size, err := m.Resources.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 *WindowsContainerResources) 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 *WindowsContainerResources) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *WindowsContainerResources) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.AffinityCpus) > 0 { for iNdEx := len(m.AffinityCpus) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.AffinityCpus[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x32 } } if m.RootfsSizeInBytes != 0 { i = encodeVarintApi(dAtA, i, uint64(m.RootfsSizeInBytes)) i-- dAtA[i] = 0x28 } if m.MemoryLimitInBytes != 0 { i = encodeVarintApi(dAtA, i, uint64(m.MemoryLimitInBytes)) i-- dAtA[i] = 0x20 } if m.CpuMaximum != 0 { i = encodeVarintApi(dAtA, i, uint64(m.CpuMaximum)) i-- dAtA[i] = 0x18 } if m.CpuCount != 0 { i = encodeVarintApi(dAtA, i, uint64(m.CpuCount)) i-- dAtA[i] = 0x10 } if m.CpuShares != 0 { i = encodeVarintApi(dAtA, i, uint64(m.CpuShares)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } func (m *WindowsCpuGroupAffinity) 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 *WindowsCpuGroupAffinity) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *WindowsCpuGroupAffinity) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.CpuGroup != 0 { i = encodeVarintApi(dAtA, i, uint64(m.CpuGroup)) i-- dAtA[i] = 0x10 } if m.CpuMask != 0 { i = encodeVarintApi(dAtA, i, uint64(m.CpuMask)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } func (m *ContainerMetadata) 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 *ContainerMetadata) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ContainerMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Attempt != 0 { i = encodeVarintApi(dAtA, i, uint64(m.Attempt)) i-- dAtA[i] = 0x10 } 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 *Device) 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 *Device) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *Device) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Permissions) > 0 { i -= len(m.Permissions) copy(dAtA[i:], m.Permissions) i = encodeVarintApi(dAtA, i, uint64(len(m.Permissions))) i-- dAtA[i] = 0x1a } if len(m.HostPath) > 0 { i -= len(m.HostPath) copy(dAtA[i:], m.HostPath) i = encodeVarintApi(dAtA, i, uint64(len(m.HostPath))) i-- dAtA[i] = 0x12 } if len(m.ContainerPath) > 0 { i -= len(m.ContainerPath) copy(dAtA[i:], m.ContainerPath) i = encodeVarintApi(dAtA, i, uint64(len(m.ContainerPath))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *CDIDevice) 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 *CDIDevice) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *CDIDevice) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l 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 *ContainerConfig) 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 *ContainerConfig) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ContainerConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.CDIDevices) > 0 { for iNdEx := len(m.CDIDevices) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.CDIDevices[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1 i-- dAtA[i] = 0x8a } } if m.Windows != nil { { size, err := m.Windows.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1 i-- dAtA[i] = 0x82 } 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] = 0x7a } if m.Tty { i-- if m.Tty { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x70 } if m.StdinOnce { i-- if m.StdinOnce { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x68 } if m.Stdin { i-- if m.Stdin { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x60 } if len(m.LogPath) > 0 { i -= len(m.LogPath) copy(dAtA[i:], m.LogPath) i = encodeVarintApi(dAtA, i, uint64(len(m.LogPath))) i-- dAtA[i] = 0x5a } if len(m.Annotations) > 0 { for k := range m.Annotations { v := m.Annotations[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintApi(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintApi(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintApi(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x52 } } if len(m.Labels) > 0 { for k := range m.Labels { v := m.Labels[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintApi(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintApi(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintApi(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x4a } } if len(m.Devices) > 0 { for iNdEx := len(m.Devices) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Devices[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x42 } } if len(m.Mounts) > 0 { for iNdEx := len(m.Mounts) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Mounts[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x3a } } if len(m.Envs) > 0 { for iNdEx := len(m.Envs) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Envs[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x32 } } if len(m.WorkingDir) > 0 { i -= len(m.WorkingDir) copy(dAtA[i:], m.WorkingDir) i = encodeVarintApi(dAtA, i, uint64(len(m.WorkingDir))) i-- dAtA[i] = 0x2a } if len(m.Args) > 0 { for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.Args[iNdEx]) copy(dAtA[i:], m.Args[iNdEx]) i = encodeVarintApi(dAtA, i, uint64(len(m.Args[iNdEx]))) i-- dAtA[i] = 0x22 } } if len(m.Command) > 0 { for iNdEx := len(m.Command) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.Command[iNdEx]) copy(dAtA[i:], m.Command[iNdEx]) i = encodeVarintApi(dAtA, i, uint64(len(m.Command[iNdEx]))) i-- dAtA[i] = 0x1a } } 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] = 0x12 } if m.Metadata != nil { { size, err := m.Metadata.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 *CreateContainerRequest) 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 *CreateContainerRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *CreateContainerRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.SandboxConfig != nil { { size, err := m.SandboxConfig.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1a } if m.Config != nil { { size, err := m.Config.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } if len(m.PodSandboxId) > 0 { i -= len(m.PodSandboxId) copy(dAtA[i:], m.PodSandboxId) i = encodeVarintApi(dAtA, i, uint64(len(m.PodSandboxId))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *CreateContainerResponse) 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 *CreateContainerResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *CreateContainerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.ContainerId) > 0 { i -= len(m.ContainerId) copy(dAtA[i:], m.ContainerId) i = encodeVarintApi(dAtA, i, uint64(len(m.ContainerId))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *StartContainerRequest) 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 *StartContainerRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *StartContainerRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.ContainerId) > 0 { i -= len(m.ContainerId) copy(dAtA[i:], m.ContainerId) i = encodeVarintApi(dAtA, i, uint64(len(m.ContainerId))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *StartContainerResponse) 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 *StartContainerResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *StartContainerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l return len(dAtA) - i, nil } func (m *StopContainerRequest) 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 *StopContainerRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *StopContainerRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Timeout != 0 { i = encodeVarintApi(dAtA, i, uint64(m.Timeout)) i-- dAtA[i] = 0x10 } if len(m.ContainerId) > 0 { i -= len(m.ContainerId) copy(dAtA[i:], m.ContainerId) i = encodeVarintApi(dAtA, i, uint64(len(m.ContainerId))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *StopContainerResponse) 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 *StopContainerResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *StopContainerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l return len(dAtA) - i, nil } func (m *RemoveContainerRequest) 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 *RemoveContainerRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *RemoveContainerRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.ContainerId) > 0 { i -= len(m.ContainerId) copy(dAtA[i:], m.ContainerId) i = encodeVarintApi(dAtA, i, uint64(len(m.ContainerId))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *RemoveContainerResponse) 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 *RemoveContainerResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *RemoveContainerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l return len(dAtA) - i, nil } func (m *ContainerStateValue) 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 *ContainerStateValue) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ContainerStateValue) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.State != 0 { i = encodeVarintApi(dAtA, i, uint64(m.State)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } func (m *ContainerFilter) 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 *ContainerFilter) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ContainerFilter) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.LabelSelector) > 0 { for k := range m.LabelSelector { v := m.LabelSelector[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintApi(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintApi(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintApi(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x22 } } if len(m.PodSandboxId) > 0 { i -= len(m.PodSandboxId) copy(dAtA[i:], m.PodSandboxId) i = encodeVarintApi(dAtA, i, uint64(len(m.PodSandboxId))) i-- dAtA[i] = 0x1a } if m.State != nil { { size, err := m.State.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } if len(m.Id) > 0 { i -= len(m.Id) copy(dAtA[i:], m.Id) i = encodeVarintApi(dAtA, i, uint64(len(m.Id))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ListContainersRequest) 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 *ListContainersRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListContainersRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Filter != nil { { size, err := m.Filter.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 *Container) 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 *Container) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *Container) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = 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] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintApi(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintApi(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintApi(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x4a } } if len(m.Labels) > 0 { for k := range m.Labels { v := m.Labels[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintApi(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintApi(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintApi(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x42 } } if m.CreatedAt != 0 { i = encodeVarintApi(dAtA, i, uint64(m.CreatedAt)) i-- dAtA[i] = 0x38 } if m.State != 0 { i = encodeVarintApi(dAtA, i, uint64(m.State)) i-- dAtA[i] = 0x30 } if len(m.ImageRef) > 0 { i -= len(m.ImageRef) copy(dAtA[i:], m.ImageRef) i = encodeVarintApi(dAtA, i, uint64(len(m.ImageRef))) i-- dAtA[i] = 0x2a } 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] = 0x22 } if m.Metadata != nil { { size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1a } if len(m.PodSandboxId) > 0 { i -= len(m.PodSandboxId) copy(dAtA[i:], m.PodSandboxId) i = encodeVarintApi(dAtA, i, uint64(len(m.PodSandboxId))) i-- dAtA[i] = 0x12 } if len(m.Id) > 0 { i -= len(m.Id) copy(dAtA[i:], m.Id) i = encodeVarintApi(dAtA, i, uint64(len(m.Id))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ListContainersResponse) 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 *ListContainersResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListContainersResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Containers) > 0 { for iNdEx := len(m.Containers) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Containers[iNdEx].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 *ContainerStatusRequest) 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 *ContainerStatusRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ContainerStatusRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Verbose { i-- if m.Verbose { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x10 } if len(m.ContainerId) > 0 { i -= len(m.ContainerId) copy(dAtA[i:], m.ContainerId) i = encodeVarintApi(dAtA, i, uint64(len(m.ContainerId))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ContainerStatus) 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 *ContainerStatus) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ContainerStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = 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]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1 i-- dAtA[i] = 0x82 } if len(m.LogPath) > 0 { i -= len(m.LogPath) copy(dAtA[i:], m.LogPath) i = encodeVarintApi(dAtA, i, uint64(len(m.LogPath))) i-- dAtA[i] = 0x7a } if len(m.Mounts) > 0 { for iNdEx := len(m.Mounts) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Mounts[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x72 } } if len(m.Annotations) > 0 { for k := range m.Annotations { v := m.Annotations[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintApi(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintApi(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintApi(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x6a } } if len(m.Labels) > 0 { for k := range m.Labels { v := m.Labels[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintApi(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintApi(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintApi(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x62 } } if len(m.Message) > 0 { i -= len(m.Message) copy(dAtA[i:], m.Message) i = encodeVarintApi(dAtA, i, uint64(len(m.Message))) i-- dAtA[i] = 0x5a } if len(m.Reason) > 0 { i -= len(m.Reason) copy(dAtA[i:], m.Reason) i = encodeVarintApi(dAtA, i, uint64(len(m.Reason))) i-- dAtA[i] = 0x52 } if len(m.ImageRef) > 0 { i -= len(m.ImageRef) copy(dAtA[i:], m.ImageRef) i = encodeVarintApi(dAtA, i, uint64(len(m.ImageRef))) i-- dAtA[i] = 0x4a } 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] = 0x42 } if m.ExitCode != 0 { i = encodeVarintApi(dAtA, i, uint64(m.ExitCode)) i-- dAtA[i] = 0x38 } if m.FinishedAt != 0 { i = encodeVarintApi(dAtA, i, uint64(m.FinishedAt)) i-- dAtA[i] = 0x30 } if m.StartedAt != 0 { i = encodeVarintApi(dAtA, i, uint64(m.StartedAt)) i-- dAtA[i] = 0x28 } if m.CreatedAt != 0 { i = encodeVarintApi(dAtA, i, uint64(m.CreatedAt)) i-- dAtA[i] = 0x20 } if m.State != 0 { i = encodeVarintApi(dAtA, i, uint64(m.State)) i-- dAtA[i] = 0x18 } if m.Metadata != nil { { size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } if len(m.Id) > 0 { i -= len(m.Id) copy(dAtA[i:], m.Id) i = encodeVarintApi(dAtA, i, uint64(len(m.Id))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ContainerStatusResponse) 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 *ContainerStatusResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ContainerStatusResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Info) > 0 { for k := range m.Info { v := m.Info[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintApi(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintApi(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintApi(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x12 } } if m.Status != nil { { size, err := m.Status.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 *ContainerResources) 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 *ContainerResources) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ContainerResources) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Windows != nil { { size, err := m.Windows.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } 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 *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) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *UpdateContainerResourcesRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *UpdateContainerResourcesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Annotations) > 0 { for k := range m.Annotations { v := m.Annotations[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintApi(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintApi(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintApi(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x22 } } if m.Windows != nil { { size, err := m.Windows.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1a } 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] = 0x12 } if len(m.ContainerId) > 0 { i -= len(m.ContainerId) copy(dAtA[i:], m.ContainerId) i = encodeVarintApi(dAtA, i, uint64(len(m.ContainerId))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *UpdateContainerResourcesResponse) 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 *UpdateContainerResourcesResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *UpdateContainerResourcesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l return len(dAtA) - i, nil } func (m *ExecSyncRequest) 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 *ExecSyncRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ExecSyncRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Timeout != 0 { i = encodeVarintApi(dAtA, i, uint64(m.Timeout)) i-- dAtA[i] = 0x18 } if len(m.Cmd) > 0 { for iNdEx := len(m.Cmd) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.Cmd[iNdEx]) copy(dAtA[i:], m.Cmd[iNdEx]) i = encodeVarintApi(dAtA, i, uint64(len(m.Cmd[iNdEx]))) i-- dAtA[i] = 0x12 } } if len(m.ContainerId) > 0 { i -= len(m.ContainerId) copy(dAtA[i:], m.ContainerId) i = encodeVarintApi(dAtA, i, uint64(len(m.ContainerId))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ExecSyncResponse) 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 *ExecSyncResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ExecSyncResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.ExitCode != 0 { i = encodeVarintApi(dAtA, i, uint64(m.ExitCode)) i-- dAtA[i] = 0x18 } if len(m.Stderr) > 0 { i -= len(m.Stderr) copy(dAtA[i:], m.Stderr) i = encodeVarintApi(dAtA, i, uint64(len(m.Stderr))) i-- dAtA[i] = 0x12 } if len(m.Stdout) > 0 { i -= len(m.Stdout) copy(dAtA[i:], m.Stdout) i = encodeVarintApi(dAtA, i, uint64(len(m.Stdout))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ExecRequest) 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 *ExecRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ExecRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Stderr { i-- if m.Stderr { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x30 } if m.Stdout { i-- if m.Stdout { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x28 } if m.Stdin { i-- if m.Stdin { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x20 } if m.Tty { i-- if m.Tty { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x18 } if len(m.Cmd) > 0 { for iNdEx := len(m.Cmd) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.Cmd[iNdEx]) copy(dAtA[i:], m.Cmd[iNdEx]) i = encodeVarintApi(dAtA, i, uint64(len(m.Cmd[iNdEx]))) i-- dAtA[i] = 0x12 } } if len(m.ContainerId) > 0 { i -= len(m.ContainerId) copy(dAtA[i:], m.ContainerId) i = encodeVarintApi(dAtA, i, uint64(len(m.ContainerId))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ExecResponse) 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 *ExecResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ExecResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Url) > 0 { i -= len(m.Url) copy(dAtA[i:], m.Url) i = encodeVarintApi(dAtA, i, uint64(len(m.Url))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *AttachRequest) 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 *AttachRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *AttachRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Stderr { i-- if m.Stderr { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x28 } if m.Stdout { i-- if m.Stdout { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x20 } if m.Tty { i-- if m.Tty { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x18 } if m.Stdin { i-- if m.Stdin { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x10 } if len(m.ContainerId) > 0 { i -= len(m.ContainerId) copy(dAtA[i:], m.ContainerId) i = encodeVarintApi(dAtA, i, uint64(len(m.ContainerId))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *AttachResponse) 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 *AttachResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *AttachResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Url) > 0 { i -= len(m.Url) copy(dAtA[i:], m.Url) i = encodeVarintApi(dAtA, i, uint64(len(m.Url))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *PortForwardRequest) 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 *PortForwardRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *PortForwardRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Port) > 0 { dAtA92 := make([]byte, len(m.Port)*10) var j91 int for _, num1 := range m.Port { num := uint64(num1) for num >= 1<<7 { dAtA92[j91] = uint8(uint64(num)&0x7f | 0x80) num >>= 7 j91++ } dAtA92[j91] = uint8(num) j91++ } i -= j91 copy(dAtA[i:], dAtA92[:j91]) i = encodeVarintApi(dAtA, i, uint64(j91)) i-- dAtA[i] = 0x12 } if len(m.PodSandboxId) > 0 { i -= len(m.PodSandboxId) copy(dAtA[i:], m.PodSandboxId) i = encodeVarintApi(dAtA, i, uint64(len(m.PodSandboxId))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *PortForwardResponse) 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 *PortForwardResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *PortForwardResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Url) > 0 { i -= len(m.Url) copy(dAtA[i:], m.Url) i = encodeVarintApi(dAtA, i, uint64(len(m.Url))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ImageFilter) 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 *ImageFilter) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ImageFilter) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = 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] = 0xa } return len(dAtA) - i, nil } func (m *ListImagesRequest) 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 *ListImagesRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListImagesRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Filter != nil { { size, err := m.Filter.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 *Image) 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 *Image) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *Image) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Pinned { i-- if m.Pinned { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x40 } if m.Spec != nil { { size, err := m.Spec.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x3a } if len(m.Username) > 0 { i -= len(m.Username) copy(dAtA[i:], m.Username) i = encodeVarintApi(dAtA, i, uint64(len(m.Username))) i-- dAtA[i] = 0x32 } if m.Uid != nil { { size, err := m.Uid.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x2a } if m.Size_ != 0 { i = encodeVarintApi(dAtA, i, uint64(m.Size_)) i-- dAtA[i] = 0x20 } if len(m.RepoDigests) > 0 { for iNdEx := len(m.RepoDigests) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.RepoDigests[iNdEx]) copy(dAtA[i:], m.RepoDigests[iNdEx]) i = encodeVarintApi(dAtA, i, uint64(len(m.RepoDigests[iNdEx]))) i-- dAtA[i] = 0x1a } } if len(m.RepoTags) > 0 { for iNdEx := len(m.RepoTags) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.RepoTags[iNdEx]) copy(dAtA[i:], m.RepoTags[iNdEx]) i = encodeVarintApi(dAtA, i, uint64(len(m.RepoTags[iNdEx]))) i-- dAtA[i] = 0x12 } } if len(m.Id) > 0 { i -= len(m.Id) copy(dAtA[i:], m.Id) i = encodeVarintApi(dAtA, i, uint64(len(m.Id))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ListImagesResponse) 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 *ListImagesResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListImagesResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Images) > 0 { for iNdEx := len(m.Images) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Images[iNdEx].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 *ImageStatusRequest) 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 *ImageStatusRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ImageStatusRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Verbose { i-- if m.Verbose { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x10 } 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] = 0xa } return len(dAtA) - i, nil } func (m *ImageStatusResponse) 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 *ImageStatusResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ImageStatusResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Info) > 0 { for k := range m.Info { v := m.Info[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintApi(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintApi(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintApi(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x12 } } 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] = 0xa } return len(dAtA) - i, nil } func (m *AuthConfig) 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 *AuthConfig) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *AuthConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.RegistryToken) > 0 { i -= len(m.RegistryToken) copy(dAtA[i:], m.RegistryToken) i = encodeVarintApi(dAtA, i, uint64(len(m.RegistryToken))) i-- dAtA[i] = 0x32 } if len(m.IdentityToken) > 0 { i -= len(m.IdentityToken) copy(dAtA[i:], m.IdentityToken) i = encodeVarintApi(dAtA, i, uint64(len(m.IdentityToken))) i-- dAtA[i] = 0x2a } if len(m.ServerAddress) > 0 { i -= len(m.ServerAddress) copy(dAtA[i:], m.ServerAddress) i = encodeVarintApi(dAtA, i, uint64(len(m.ServerAddress))) i-- dAtA[i] = 0x22 } if len(m.Auth) > 0 { i -= len(m.Auth) copy(dAtA[i:], m.Auth) i = encodeVarintApi(dAtA, i, uint64(len(m.Auth))) i-- dAtA[i] = 0x1a } if len(m.Password) > 0 { i -= len(m.Password) copy(dAtA[i:], m.Password) i = encodeVarintApi(dAtA, i, uint64(len(m.Password))) i-- dAtA[i] = 0x12 } if len(m.Username) > 0 { i -= len(m.Username) copy(dAtA[i:], m.Username) i = encodeVarintApi(dAtA, i, uint64(len(m.Username))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *PullImageRequest) 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 *PullImageRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *PullImageRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.SandboxConfig != nil { { size, err := m.SandboxConfig.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1a } if m.Auth != nil { { size, err := m.Auth.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } 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] = 0xa } return len(dAtA) - i, nil } func (m *PullImageResponse) 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 *PullImageResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *PullImageResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.ImageRef) > 0 { i -= len(m.ImageRef) copy(dAtA[i:], m.ImageRef) i = encodeVarintApi(dAtA, i, uint64(len(m.ImageRef))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *RemoveImageRequest) 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 *RemoveImageRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *RemoveImageRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = 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] = 0xa } return len(dAtA) - i, nil } func (m *RemoveImageResponse) 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 *RemoveImageResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *RemoveImageResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l return len(dAtA) - i, nil } func (m *NetworkConfig) 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 *NetworkConfig) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *NetworkConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.PodCidr) > 0 { i -= len(m.PodCidr) copy(dAtA[i:], m.PodCidr) i = encodeVarintApi(dAtA, i, uint64(len(m.PodCidr))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *RuntimeConfig) 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 *RuntimeConfig) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *RuntimeConfig) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.NetworkConfig != nil { { size, err := m.NetworkConfig.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 *UpdateRuntimeConfigRequest) 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 *UpdateRuntimeConfigRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *UpdateRuntimeConfigRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.RuntimeConfig != nil { { size, err := m.RuntimeConfig.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 *UpdateRuntimeConfigResponse) 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 *UpdateRuntimeConfigResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *UpdateRuntimeConfigResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l return len(dAtA) - i, nil } func (m *RuntimeCondition) 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 *RuntimeCondition) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *RuntimeCondition) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Message) > 0 { i -= len(m.Message) copy(dAtA[i:], m.Message) i = encodeVarintApi(dAtA, i, uint64(len(m.Message))) i-- dAtA[i] = 0x22 } if len(m.Reason) > 0 { i -= len(m.Reason) copy(dAtA[i:], m.Reason) i = encodeVarintApi(dAtA, i, uint64(len(m.Reason))) i-- dAtA[i] = 0x1a } if m.Status { i-- if m.Status { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x10 } if len(m.Type) > 0 { i -= len(m.Type) copy(dAtA[i:], m.Type) i = encodeVarintApi(dAtA, i, uint64(len(m.Type))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *RuntimeStatus) 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 *RuntimeStatus) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *RuntimeStatus) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Conditions) > 0 { for iNdEx := len(m.Conditions) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Conditions[iNdEx].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 *StatusRequest) 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 *StatusRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *StatusRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Verbose { i-- if m.Verbose { dAtA[i] = 1 } else { dAtA[i] = 0 } i-- dAtA[i] = 0x8 } 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) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *StatusResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *StatusResponse) 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] = 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] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintApi(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintApi(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintApi(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x12 } } if m.Status != nil { { size, err := m.Status.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 *ImageFsInfoRequest) 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 *ImageFsInfoRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ImageFsInfoRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l return len(dAtA) - i, nil } func (m *UInt64Value) 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 *UInt64Value) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *UInt64Value) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Value != 0 { i = encodeVarintApi(dAtA, i, uint64(m.Value)) i-- dAtA[i] = 0x8 } return len(dAtA) - i, nil } func (m *FilesystemIdentifier) 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 *FilesystemIdentifier) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *FilesystemIdentifier) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Mountpoint) > 0 { i -= len(m.Mountpoint) copy(dAtA[i:], m.Mountpoint) i = encodeVarintApi(dAtA, i, uint64(len(m.Mountpoint))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *FilesystemUsage) 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 *FilesystemUsage) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *FilesystemUsage) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.InodesUsed != nil { { size, err := m.InodesUsed.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x22 } if m.UsedBytes != nil { { size, err := m.UsedBytes.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1a } if m.FsId != nil { { size, err := m.FsId.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 *WindowsFilesystemUsage) 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 *WindowsFilesystemUsage) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *WindowsFilesystemUsage) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.UsedBytes != nil { { size, err := m.UsedBytes.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1a } if m.FsId != nil { { size, err := m.FsId.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 *ImageFsInfoResponse) 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 *ImageFsInfoResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ImageFsInfoResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = 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-- { { size, err := m.ImageFilesystems[iNdEx].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 *ContainerStatsRequest) 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 *ContainerStatsRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ContainerStatsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.ContainerId) > 0 { i -= len(m.ContainerId) copy(dAtA[i:], m.ContainerId) i = encodeVarintApi(dAtA, i, uint64(len(m.ContainerId))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ContainerStatsResponse) 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 *ContainerStatsResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ContainerStatsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Stats != nil { { size, err := m.Stats.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 *ListContainerStatsRequest) 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 *ListContainerStatsRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListContainerStatsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Filter != nil { { size, err := m.Filter.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 *ContainerStatsFilter) 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 *ContainerStatsFilter) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ContainerStatsFilter) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.LabelSelector) > 0 { for k := range m.LabelSelector { v := m.LabelSelector[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintApi(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintApi(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintApi(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x1a } } if len(m.PodSandboxId) > 0 { i -= len(m.PodSandboxId) copy(dAtA[i:], m.PodSandboxId) i = encodeVarintApi(dAtA, i, uint64(len(m.PodSandboxId))) i-- dAtA[i] = 0x12 } if len(m.Id) > 0 { i -= len(m.Id) copy(dAtA[i:], m.Id) i = encodeVarintApi(dAtA, i, uint64(len(m.Id))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ListContainerStatsResponse) 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 *ListContainerStatsResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListContainerStatsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Stats) > 0 { for iNdEx := len(m.Stats) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Stats[iNdEx].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 *ContainerAttributes) 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 *ContainerAttributes) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ContainerAttributes) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Annotations) > 0 { for k := range m.Annotations { v := m.Annotations[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintApi(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintApi(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintApi(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x22 } } if len(m.Labels) > 0 { for k := range m.Labels { v := m.Labels[k] baseI := i i -= len(v) copy(dAtA[i:], v) i = encodeVarintApi(dAtA, i, uint64(len(v))) i-- dAtA[i] = 0x12 i -= len(k) copy(dAtA[i:], k) i = encodeVarintApi(dAtA, i, uint64(len(k))) i-- dAtA[i] = 0xa i = encodeVarintApi(dAtA, i, uint64(baseI-i)) i-- dAtA[i] = 0x1a } } if m.Metadata != nil { { size, err := m.Metadata.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } if len(m.Id) > 0 { i -= len(m.Id) copy(dAtA[i:], m.Id) i = encodeVarintApi(dAtA, i, uint64(len(m.Id))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ContainerStats) 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 *ContainerStats) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ContainerStats) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = 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]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x22 } if m.Memory != nil { { size, err := m.Memory.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1a } if m.Cpu != nil { { size, err := m.Cpu.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } if m.Attributes != nil { { size, err := m.Attributes.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 *WindowsContainerStats) 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 *WindowsContainerStats) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *WindowsContainerStats) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.WritableLayer != nil { { size, err := m.WritableLayer.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x22 } if m.Memory != nil { { size, err := m.Memory.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1a } if m.Cpu != nil { { size, err := m.Cpu.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x12 } if m.Attributes != nil { { size, err := m.Attributes.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 *CpuUsage) 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 *CpuUsage) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *CpuUsage) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.UsageNanoCores != nil { { size, err := m.UsageNanoCores.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1a } if m.UsageCoreNanoSeconds != nil { { size, err := m.UsageCoreNanoSeconds.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 *WindowsCpuUsage) 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 *WindowsCpuUsage) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *WindowsCpuUsage) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.UsageNanoCores != nil { { size, err := m.UsageNanoCores.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1a } if m.UsageCoreNanoSeconds != nil { { size, err := m.UsageCoreNanoSeconds.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 *MemoryUsage) 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 *MemoryUsage) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *MemoryUsage) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.MajorPageFaults != nil { { size, err := m.MajorPageFaults.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x3a } if m.PageFaults != nil { { size, err := m.PageFaults.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x32 } if m.RssBytes != nil { { size, err := m.RssBytes.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x2a } if m.UsageBytes != nil { { size, err := m.UsageBytes.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x22 } if m.AvailableBytes != nil { { size, err := m.AvailableBytes.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1a } if m.WorkingSetBytes != nil { { size, err := m.WorkingSetBytes.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 *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) n, err := m.MarshalToSizedBuffer(dAtA[:size]) if err != nil { return nil, err } return dAtA[:n], nil } func (m *WindowsMemoryUsage) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *WindowsMemoryUsage) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = 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]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x22 } if m.AvailableBytes != nil { { size, err := m.AvailableBytes.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x1a } if m.WorkingSetBytes != nil { { size, err := m.WorkingSetBytes.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 *ReopenContainerLogRequest) 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 *ReopenContainerLogRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ReopenContainerLogRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.ContainerId) > 0 { i -= len(m.ContainerId) copy(dAtA[i:], m.ContainerId) i = encodeVarintApi(dAtA, i, uint64(len(m.ContainerId))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ReopenContainerLogResponse) 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 *ReopenContainerLogResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ReopenContainerLogResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l return len(dAtA) - i, nil } func (m *CheckpointContainerRequest) 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 *CheckpointContainerRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *CheckpointContainerRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Timeout != 0 { i = encodeVarintApi(dAtA, i, uint64(m.Timeout)) i-- dAtA[i] = 0x18 } if len(m.Location) > 0 { i -= len(m.Location) copy(dAtA[i:], m.Location) i = encodeVarintApi(dAtA, i, uint64(len(m.Location))) i-- dAtA[i] = 0x12 } if len(m.ContainerId) > 0 { i -= len(m.ContainerId) copy(dAtA[i:], m.ContainerId) i = encodeVarintApi(dAtA, i, uint64(len(m.ContainerId))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *CheckpointContainerResponse) 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 *CheckpointContainerResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *CheckpointContainerResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l return len(dAtA) - i, nil } func (m *GetEventsRequest) 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 *GetEventsRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *GetEventsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l return len(dAtA) - i, nil } func (m *ContainerEventResponse) 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 *ContainerEventResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ContainerEventResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.ContainersStatuses) > 0 { for iNdEx := len(m.ContainersStatuses) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.ContainersStatuses[iNdEx].MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x2a } } if m.PodSandboxStatus != nil { { size, err := m.PodSandboxStatus.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x22 } if m.CreatedAt != 0 { i = encodeVarintApi(dAtA, i, uint64(m.CreatedAt)) i-- dAtA[i] = 0x18 } if m.ContainerEventType != 0 { i = encodeVarintApi(dAtA, i, uint64(m.ContainerEventType)) i-- dAtA[i] = 0x10 } if len(m.ContainerId) > 0 { i -= len(m.ContainerId) copy(dAtA[i:], m.ContainerId) i = encodeVarintApi(dAtA, i, uint64(len(m.ContainerId))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ListMetricDescriptorsRequest) 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 *ListMetricDescriptorsRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListMetricDescriptorsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l return len(dAtA) - i, nil } func (m *ListMetricDescriptorsResponse) 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 *ListMetricDescriptorsResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListMetricDescriptorsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Descriptors) > 0 { for iNdEx := len(m.Descriptors) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Descriptors[iNdEx].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 *MetricDescriptor) 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 *MetricDescriptor) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *MetricDescriptor) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.LabelKeys) > 0 { for iNdEx := len(m.LabelKeys) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.LabelKeys[iNdEx]) copy(dAtA[i:], m.LabelKeys[iNdEx]) i = encodeVarintApi(dAtA, i, uint64(len(m.LabelKeys[iNdEx]))) i-- dAtA[i] = 0x1a } } if len(m.Help) > 0 { i -= len(m.Help) copy(dAtA[i:], m.Help) i = encodeVarintApi(dAtA, i, uint64(len(m.Help))) 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 *ListPodSandboxMetricsRequest) 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 *ListPodSandboxMetricsRequest) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListPodSandboxMetricsRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l return len(dAtA) - i, nil } func (m *ListPodSandboxMetricsResponse) 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 *ListPodSandboxMetricsResponse) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ListPodSandboxMetricsResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.PodMetrics) > 0 { for iNdEx := len(m.PodMetrics) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.PodMetrics[iNdEx].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 *PodSandboxMetrics) 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 *PodSandboxMetrics) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *PodSandboxMetrics) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.ContainerMetrics) > 0 { for iNdEx := len(m.ContainerMetrics) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.ContainerMetrics[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.Metrics) > 0 { for iNdEx := len(m.Metrics) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Metrics[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.PodSandboxId) > 0 { i -= len(m.PodSandboxId) copy(dAtA[i:], m.PodSandboxId) i = encodeVarintApi(dAtA, i, uint64(len(m.PodSandboxId))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *ContainerMetrics) 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 *ContainerMetrics) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *ContainerMetrics) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if len(m.Metrics) > 0 { for iNdEx := len(m.Metrics) - 1; iNdEx >= 0; iNdEx-- { { size, err := m.Metrics[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.ContainerId) > 0 { i -= len(m.ContainerId) copy(dAtA[i:], m.ContainerId) i = encodeVarintApi(dAtA, i, uint64(len(m.ContainerId))) i-- dAtA[i] = 0xa } return len(dAtA) - i, nil } func (m *Metric) 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 *Metric) MarshalTo(dAtA []byte) (int, error) { size := m.Size() return m.MarshalToSizedBuffer(dAtA[:size]) } func (m *Metric) MarshalToSizedBuffer(dAtA []byte) (int, error) { i := len(dAtA) _ = i var l int _ = l if m.Value != nil { { size, err := m.Value.MarshalToSizedBuffer(dAtA[:i]) if err != nil { return 0, err } i -= size i = encodeVarintApi(dAtA, i, uint64(size)) } i-- dAtA[i] = 0x2a } if len(m.LabelValues) > 0 { for iNdEx := len(m.LabelValues) - 1; iNdEx >= 0; iNdEx-- { i -= len(m.LabelValues[iNdEx]) copy(dAtA[i:], m.LabelValues[iNdEx]) i = encodeVarintApi(dAtA, i, uint64(len(m.LabelValues[iNdEx]))) i-- dAtA[i] = 0x22 } } if m.MetricType != 0 { i = encodeVarintApi(dAtA, i, uint64(m.MetricType)) i-- dAtA[i] = 0x18 } if m.Timestamp != 0 { i = encodeVarintApi(dAtA, i, uint64(m.Timestamp)) i-- dAtA[i] = 0x10 } 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 *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 for v >= 1<<7 { dAtA[offset] = uint8(v&0x7f | 0x80) v >>= 7 offset++ } dAtA[offset] = uint8(v) return base } func (m *VersionRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Version) if l > 0 { n += 1 + l + sovApi(uint64(l)) } return n } func (m *VersionResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Version) if l > 0 { n += 1 + l + sovApi(uint64(l)) } l = len(m.RuntimeName) if l > 0 { n += 1 + l + sovApi(uint64(l)) } l = len(m.RuntimeVersion) if l > 0 { n += 1 + l + sovApi(uint64(l)) } l = len(m.RuntimeApiVersion) if l > 0 { n += 1 + l + sovApi(uint64(l)) } return n } func (m *DNSConfig) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Servers) > 0 { for _, s := range m.Servers { l = len(s) n += 1 + l + sovApi(uint64(l)) } } if len(m.Searches) > 0 { for _, s := range m.Searches { l = len(s) n += 1 + l + sovApi(uint64(l)) } } if len(m.Options) > 0 { for _, s := range m.Options { l = len(s) n += 1 + l + sovApi(uint64(l)) } } return n } func (m *PortMapping) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Protocol != 0 { n += 1 + sovApi(uint64(m.Protocol)) } if m.ContainerPort != 0 { n += 1 + sovApi(uint64(m.ContainerPort)) } if m.HostPort != 0 { n += 1 + sovApi(uint64(m.HostPort)) } l = len(m.HostIp) if l > 0 { n += 1 + l + sovApi(uint64(l)) } return n } func (m *Mount) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerPath) if l > 0 { n += 1 + l + sovApi(uint64(l)) } l = len(m.HostPath) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.Readonly { n += 2 } if m.SelinuxRelabel { n += 2 } if m.Propagation != 0 { n += 1 + sovApi(uint64(m.Propagation)) } if len(m.UidMappings) > 0 { for _, e := range m.UidMappings { l = e.Size() n += 1 + l + sovApi(uint64(l)) } } if len(m.GidMappings) > 0 { for _, e := range m.GidMappings { l = e.Size() 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 } func (m *IDMapping) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.HostId != 0 { n += 1 + sovApi(uint64(m.HostId)) } if m.ContainerId != 0 { n += 1 + sovApi(uint64(m.ContainerId)) } if m.Length != 0 { n += 1 + sovApi(uint64(m.Length)) } return n } func (m *UserNamespace) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Mode != 0 { n += 1 + sovApi(uint64(m.Mode)) } if len(m.Uids) > 0 { for _, e := range m.Uids { l = e.Size() n += 1 + l + sovApi(uint64(l)) } } if len(m.Gids) > 0 { for _, e := range m.Gids { l = e.Size() n += 1 + l + sovApi(uint64(l)) } } return n } func (m *NamespaceOption) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Network != 0 { n += 1 + sovApi(uint64(m.Network)) } if m.Pid != 0 { n += 1 + sovApi(uint64(m.Pid)) } if m.Ipc != 0 { n += 1 + sovApi(uint64(m.Ipc)) } l = len(m.TargetId) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.UsernsOptions != nil { l = m.UsernsOptions.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *Int64Value) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Value != 0 { n += 1 + sovApi(uint64(m.Value)) } return n } func (m *LinuxSandboxSecurityContext) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.NamespaceOptions != nil { l = m.NamespaceOptions.Size() n += 1 + l + sovApi(uint64(l)) } if m.SelinuxOptions != nil { l = m.SelinuxOptions.Size() n += 1 + l + sovApi(uint64(l)) } if m.RunAsUser != nil { l = m.RunAsUser.Size() n += 1 + l + sovApi(uint64(l)) } if m.ReadonlyRootfs { n += 2 } if len(m.SupplementalGroups) > 0 { l = 0 for _, e := range m.SupplementalGroups { l += sovApi(uint64(e)) } n += 1 + sovApi(uint64(l)) + l } if m.Privileged { n += 2 } l = len(m.SeccompProfilePath) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.RunAsGroup != nil { l = m.RunAsGroup.Size() n += 1 + l + sovApi(uint64(l)) } if m.Seccomp != nil { l = m.Seccomp.Size() n += 1 + l + sovApi(uint64(l)) } if m.Apparmor != nil { l = m.Apparmor.Size() n += 1 + l + sovApi(uint64(l)) } if m.SupplementalGroupsPolicy != 0 { n += 1 + sovApi(uint64(m.SupplementalGroupsPolicy)) } return n } func (m *SecurityProfile) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.ProfileType != 0 { n += 1 + sovApi(uint64(m.ProfileType)) } l = len(m.LocalhostRef) if l > 0 { n += 1 + l + sovApi(uint64(l)) } return n } func (m *LinuxPodSandboxConfig) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.CgroupParent) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.SecurityContext != nil { l = m.SecurityContext.Size() n += 1 + l + sovApi(uint64(l)) } if len(m.Sysctls) > 0 { for k, v := range m.Sysctls { _ = k _ = v mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + len(v) + sovApi(uint64(len(v))) n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) } } if m.Overhead != nil { l = m.Overhead.Size() n += 1 + l + sovApi(uint64(l)) } if m.Resources != nil { l = m.Resources.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *PodSandboxMetadata) 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)) } l = len(m.Uid) if l > 0 { n += 1 + l + sovApi(uint64(l)) } l = len(m.Namespace) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.Attempt != 0 { n += 1 + sovApi(uint64(m.Attempt)) } return n } func (m *PodSandboxConfig) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Metadata != nil { l = m.Metadata.Size() n += 1 + l + sovApi(uint64(l)) } l = len(m.Hostname) if l > 0 { n += 1 + l + sovApi(uint64(l)) } l = len(m.LogDirectory) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.DnsConfig != nil { l = m.DnsConfig.Size() n += 1 + l + sovApi(uint64(l)) } if len(m.PortMappings) > 0 { for _, e := range m.PortMappings { l = e.Size() n += 1 + l + sovApi(uint64(l)) } } if len(m.Labels) > 0 { for k, v := range m.Labels { _ = k _ = v mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + len(v) + sovApi(uint64(len(v))) n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) } } if len(m.Annotations) > 0 { for k, v := range m.Annotations { _ = k _ = v mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + len(v) + sovApi(uint64(len(v))) n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) } } if m.Linux != nil { l = m.Linux.Size() n += 1 + l + sovApi(uint64(l)) } if m.Windows != nil { l = m.Windows.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *RunPodSandboxRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Config != nil { l = m.Config.Size() n += 1 + l + sovApi(uint64(l)) } l = len(m.RuntimeHandler) if l > 0 { n += 1 + l + sovApi(uint64(l)) } return n } func (m *RunPodSandboxResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.PodSandboxId) if l > 0 { n += 1 + l + sovApi(uint64(l)) } return n } func (m *StopPodSandboxRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.PodSandboxId) if l > 0 { n += 1 + l + sovApi(uint64(l)) } return n } func (m *StopPodSandboxResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l return n } func (m *RemovePodSandboxRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.PodSandboxId) if l > 0 { n += 1 + l + sovApi(uint64(l)) } return n } func (m *RemovePodSandboxResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l return n } func (m *PodSandboxStatusRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.PodSandboxId) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.Verbose { n += 2 } return n } func (m *PodIP) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Ip) if l > 0 { n += 1 + l + sovApi(uint64(l)) } return n } func (m *PodSandboxNetworkStatus) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Ip) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if len(m.AdditionalIps) > 0 { for _, e := range m.AdditionalIps { l = e.Size() n += 1 + l + sovApi(uint64(l)) } } return n } func (m *Namespace) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Options != nil { l = m.Options.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *LinuxPodSandboxStatus) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Namespaces != nil { l = m.Namespaces.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *PodSandboxStatus) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Id) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.Metadata != nil { l = m.Metadata.Size() n += 1 + l + sovApi(uint64(l)) } if m.State != 0 { n += 1 + sovApi(uint64(m.State)) } if m.CreatedAt != 0 { n += 1 + sovApi(uint64(m.CreatedAt)) } if m.Network != nil { l = m.Network.Size() n += 1 + l + sovApi(uint64(l)) } if m.Linux != nil { l = m.Linux.Size() n += 1 + l + sovApi(uint64(l)) } if len(m.Labels) > 0 { for k, v := range m.Labels { _ = k _ = v mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + len(v) + sovApi(uint64(len(v))) n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) } } if len(m.Annotations) > 0 { for k, v := range m.Annotations { _ = k _ = v mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + len(v) + sovApi(uint64(len(v))) n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) } } l = len(m.RuntimeHandler) if l > 0 { n += 1 + l + sovApi(uint64(l)) } return n } func (m *PodSandboxStatusResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Status != nil { l = m.Status.Size() n += 1 + l + sovApi(uint64(l)) } if len(m.Info) > 0 { for k, v := range m.Info { _ = k _ = v mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + len(v) + sovApi(uint64(len(v))) n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) } } if len(m.ContainersStatuses) > 0 { for _, e := range m.ContainersStatuses { l = e.Size() n += 1 + l + sovApi(uint64(l)) } } if m.Timestamp != 0 { n += 1 + sovApi(uint64(m.Timestamp)) } return n } func (m *PodSandboxStateValue) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.State != 0 { n += 1 + sovApi(uint64(m.State)) } return n } func (m *PodSandboxFilter) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Id) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.State != nil { l = m.State.Size() n += 1 + l + sovApi(uint64(l)) } if len(m.LabelSelector) > 0 { for k, v := range m.LabelSelector { _ = k _ = v mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + len(v) + sovApi(uint64(len(v))) n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) } } return n } func (m *ListPodSandboxRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Filter != nil { l = m.Filter.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *PodSandbox) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Id) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.Metadata != nil { l = m.Metadata.Size() n += 1 + l + sovApi(uint64(l)) } if m.State != 0 { n += 1 + sovApi(uint64(m.State)) } if m.CreatedAt != 0 { n += 1 + sovApi(uint64(m.CreatedAt)) } if len(m.Labels) > 0 { for k, v := range m.Labels { _ = k _ = v mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + len(v) + sovApi(uint64(len(v))) n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) } } if len(m.Annotations) > 0 { for k, v := range m.Annotations { _ = k _ = v mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + len(v) + sovApi(uint64(len(v))) n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) } } l = len(m.RuntimeHandler) if l > 0 { n += 1 + l + sovApi(uint64(l)) } return n } func (m *ListPodSandboxResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Items) > 0 { for _, e := range m.Items { l = e.Size() n += 1 + l + sovApi(uint64(l)) } } return n } func (m *PodSandboxStatsRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.PodSandboxId) if l > 0 { n += 1 + l + sovApi(uint64(l)) } return n } func (m *PodSandboxStatsResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Stats != nil { l = m.Stats.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *PodSandboxStatsFilter) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Id) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if len(m.LabelSelector) > 0 { for k, v := range m.LabelSelector { _ = k _ = v mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + len(v) + sovApi(uint64(len(v))) n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) } } return n } func (m *ListPodSandboxStatsRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Filter != nil { l = m.Filter.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *ListPodSandboxStatsResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Stats) > 0 { for _, e := range m.Stats { l = e.Size() n += 1 + l + sovApi(uint64(l)) } } return n } func (m *PodSandboxAttributes) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Id) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.Metadata != nil { l = m.Metadata.Size() n += 1 + l + sovApi(uint64(l)) } if len(m.Labels) > 0 { for k, v := range m.Labels { _ = k _ = v mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + len(v) + sovApi(uint64(len(v))) n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) } } if len(m.Annotations) > 0 { for k, v := range m.Annotations { _ = k _ = v mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + len(v) + sovApi(uint64(len(v))) n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) } } return n } func (m *PodSandboxStats) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Attributes != nil { l = m.Attributes.Size() n += 1 + l + sovApi(uint64(l)) } if m.Linux != nil { l = m.Linux.Size() n += 1 + l + sovApi(uint64(l)) } if m.Windows != nil { l = m.Windows.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *LinuxPodSandboxStats) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Cpu != nil { l = m.Cpu.Size() n += 1 + l + sovApi(uint64(l)) } if m.Memory != nil { l = m.Memory.Size() n += 1 + l + sovApi(uint64(l)) } if m.Network != nil { l = m.Network.Size() n += 1 + l + sovApi(uint64(l)) } if m.Process != nil { l = m.Process.Size() n += 1 + l + sovApi(uint64(l)) } if len(m.Containers) > 0 { for _, e := range m.Containers { l = e.Size() n += 1 + l + sovApi(uint64(l)) } } return n } func (m *WindowsPodSandboxStats) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Cpu != nil { l = m.Cpu.Size() n += 1 + l + sovApi(uint64(l)) } if m.Memory != nil { l = m.Memory.Size() n += 1 + l + sovApi(uint64(l)) } if m.Network != nil { l = m.Network.Size() n += 1 + l + sovApi(uint64(l)) } if m.Process != nil { l = m.Process.Size() n += 1 + l + sovApi(uint64(l)) } if len(m.Containers) > 0 { for _, e := range m.Containers { l = e.Size() n += 1 + l + sovApi(uint64(l)) } } return n } func (m *NetworkUsage) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Timestamp != 0 { n += 1 + sovApi(uint64(m.Timestamp)) } if m.DefaultInterface != nil { l = m.DefaultInterface.Size() n += 1 + l + sovApi(uint64(l)) } if len(m.Interfaces) > 0 { for _, e := range m.Interfaces { l = e.Size() n += 1 + l + sovApi(uint64(l)) } } return n } func (m *WindowsNetworkUsage) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Timestamp != 0 { n += 1 + sovApi(uint64(m.Timestamp)) } if m.DefaultInterface != nil { l = m.DefaultInterface.Size() n += 1 + l + sovApi(uint64(l)) } if len(m.Interfaces) > 0 { for _, e := range m.Interfaces { l = e.Size() n += 1 + l + sovApi(uint64(l)) } } return n } func (m *NetworkInterfaceUsage) 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.RxBytes != nil { l = m.RxBytes.Size() n += 1 + l + sovApi(uint64(l)) } if m.RxErrors != nil { l = m.RxErrors.Size() n += 1 + l + sovApi(uint64(l)) } if m.TxBytes != nil { l = m.TxBytes.Size() n += 1 + l + sovApi(uint64(l)) } if m.TxErrors != nil { l = m.TxErrors.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *WindowsNetworkInterfaceUsage) 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.RxBytes != nil { l = m.RxBytes.Size() n += 1 + l + sovApi(uint64(l)) } if m.RxPacketsDropped != nil { l = m.RxPacketsDropped.Size() n += 1 + l + sovApi(uint64(l)) } if m.TxBytes != nil { l = m.TxBytes.Size() n += 1 + l + sovApi(uint64(l)) } if m.TxPacketsDropped != nil { l = m.TxPacketsDropped.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *ProcessUsage) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Timestamp != 0 { n += 1 + sovApi(uint64(m.Timestamp)) } if m.ProcessCount != nil { l = m.ProcessCount.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *WindowsProcessUsage) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Timestamp != 0 { n += 1 + sovApi(uint64(m.Timestamp)) } if m.ProcessCount != nil { l = m.ProcessCount.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *ImageSpec) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Image) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if len(m.Annotations) > 0 { for k, v := range m.Annotations { _ = k _ = v mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + len(v) + sovApi(uint64(len(v))) 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 } func (m *KeyValue) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Key) if l > 0 { n += 1 + l + sovApi(uint64(l)) } l = len(m.Value) if l > 0 { n += 1 + l + sovApi(uint64(l)) } return n } func (m *LinuxContainerResources) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.CpuPeriod != 0 { n += 1 + sovApi(uint64(m.CpuPeriod)) } if m.CpuQuota != 0 { n += 1 + sovApi(uint64(m.CpuQuota)) } if m.CpuShares != 0 { n += 1 + sovApi(uint64(m.CpuShares)) } if m.MemoryLimitInBytes != 0 { n += 1 + sovApi(uint64(m.MemoryLimitInBytes)) } if m.OomScoreAdj != 0 { n += 1 + sovApi(uint64(m.OomScoreAdj)) } l = len(m.CpusetCpus) if l > 0 { n += 1 + l + sovApi(uint64(l)) } l = len(m.CpusetMems) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if len(m.HugepageLimits) > 0 { for _, e := range m.HugepageLimits { l = e.Size() n += 1 + l + sovApi(uint64(l)) } } if len(m.Unified) > 0 { for k, v := range m.Unified { _ = k _ = v mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + len(v) + sovApi(uint64(len(v))) n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) } } if m.MemorySwapLimitInBytes != 0 { n += 1 + sovApi(uint64(m.MemorySwapLimitInBytes)) } return n } func (m *HugepageLimit) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.PageSize) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.Limit != 0 { n += 1 + sovApi(uint64(m.Limit)) } return n } func (m *SELinuxOption) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.User) if l > 0 { n += 1 + l + sovApi(uint64(l)) } l = len(m.Role) if l > 0 { n += 1 + l + sovApi(uint64(l)) } l = len(m.Type) if l > 0 { n += 1 + l + sovApi(uint64(l)) } l = len(m.Level) if l > 0 { n += 1 + l + sovApi(uint64(l)) } return n } func (m *Capability) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.AddCapabilities) > 0 { for _, s := range m.AddCapabilities { l = len(s) n += 1 + l + sovApi(uint64(l)) } } if len(m.DropCapabilities) > 0 { for _, s := range m.DropCapabilities { l = len(s) n += 1 + l + sovApi(uint64(l)) } } if len(m.AddAmbientCapabilities) > 0 { for _, s := range m.AddAmbientCapabilities { l = len(s) n += 1 + l + sovApi(uint64(l)) } } return n } func (m *LinuxContainerSecurityContext) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Capabilities != nil { l = m.Capabilities.Size() n += 1 + l + sovApi(uint64(l)) } if m.Privileged { n += 2 } if m.NamespaceOptions != nil { l = m.NamespaceOptions.Size() n += 1 + l + sovApi(uint64(l)) } if m.SelinuxOptions != nil { l = m.SelinuxOptions.Size() n += 1 + l + sovApi(uint64(l)) } if m.RunAsUser != nil { l = m.RunAsUser.Size() n += 1 + l + sovApi(uint64(l)) } l = len(m.RunAsUsername) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.ReadonlyRootfs { n += 2 } if len(m.SupplementalGroups) > 0 { l = 0 for _, e := range m.SupplementalGroups { l += sovApi(uint64(e)) } n += 1 + sovApi(uint64(l)) + l } l = len(m.ApparmorProfile) if l > 0 { n += 1 + l + sovApi(uint64(l)) } l = len(m.SeccompProfilePath) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.NoNewPrivs { n += 2 } if m.RunAsGroup != nil { l = m.RunAsGroup.Size() n += 1 + l + sovApi(uint64(l)) } if len(m.MaskedPaths) > 0 { for _, s := range m.MaskedPaths { l = len(s) n += 1 + l + sovApi(uint64(l)) } } if len(m.ReadonlyPaths) > 0 { for _, s := range m.ReadonlyPaths { l = len(s) n += 1 + l + sovApi(uint64(l)) } } if m.Seccomp != nil { l = m.Seccomp.Size() n += 1 + l + sovApi(uint64(l)) } if m.Apparmor != nil { l = m.Apparmor.Size() n += 2 + l + sovApi(uint64(l)) } if m.SupplementalGroupsPolicy != 0 { n += 2 + sovApi(uint64(m.SupplementalGroupsPolicy)) } return n } func (m *LinuxContainerConfig) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Resources != nil { l = m.Resources.Size() n += 1 + l + sovApi(uint64(l)) } if m.SecurityContext != nil { l = m.SecurityContext.Size() n += 1 + l + sovApi(uint64(l)) } 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 } var l int _ = l if m.Network != 0 { n += 1 + sovApi(uint64(m.Network)) } return n } func (m *WindowsSandboxSecurityContext) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.RunAsUsername) if l > 0 { n += 1 + l + sovApi(uint64(l)) } l = len(m.CredentialSpec) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.HostProcess { n += 2 } if m.NamespaceOptions != nil { l = m.NamespaceOptions.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *WindowsPodSandboxConfig) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.SecurityContext != nil { l = m.SecurityContext.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *WindowsContainerSecurityContext) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.RunAsUsername) if l > 0 { n += 1 + l + sovApi(uint64(l)) } l = len(m.CredentialSpec) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.HostProcess { n += 2 } return n } func (m *WindowsContainerConfig) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Resources != nil { l = m.Resources.Size() n += 1 + l + sovApi(uint64(l)) } if m.SecurityContext != nil { l = m.SecurityContext.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *WindowsContainerResources) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.CpuShares != 0 { n += 1 + sovApi(uint64(m.CpuShares)) } if m.CpuCount != 0 { n += 1 + sovApi(uint64(m.CpuCount)) } if m.CpuMaximum != 0 { n += 1 + sovApi(uint64(m.CpuMaximum)) } if m.MemoryLimitInBytes != 0 { n += 1 + sovApi(uint64(m.MemoryLimitInBytes)) } if m.RootfsSizeInBytes != 0 { n += 1 + sovApi(uint64(m.RootfsSizeInBytes)) } if len(m.AffinityCpus) > 0 { for _, e := range m.AffinityCpus { l = e.Size() n += 1 + l + sovApi(uint64(l)) } } return n } func (m *WindowsCpuGroupAffinity) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.CpuMask != 0 { n += 1 + sovApi(uint64(m.CpuMask)) } if m.CpuGroup != 0 { n += 1 + sovApi(uint64(m.CpuGroup)) } return n } func (m *ContainerMetadata) 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.Attempt != 0 { n += 1 + sovApi(uint64(m.Attempt)) } return n } func (m *Device) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerPath) if l > 0 { n += 1 + l + sovApi(uint64(l)) } l = len(m.HostPath) if l > 0 { n += 1 + l + sovApi(uint64(l)) } l = len(m.Permissions) if l > 0 { n += 1 + l + sovApi(uint64(l)) } return n } func (m *CDIDevice) 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)) } return n } func (m *ContainerConfig) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Metadata != nil { l = m.Metadata.Size() n += 1 + l + sovApi(uint64(l)) } if m.Image != nil { l = m.Image.Size() n += 1 + l + sovApi(uint64(l)) } if len(m.Command) > 0 { for _, s := range m.Command { l = len(s) n += 1 + l + sovApi(uint64(l)) } } if len(m.Args) > 0 { for _, s := range m.Args { l = len(s) n += 1 + l + sovApi(uint64(l)) } } l = len(m.WorkingDir) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if len(m.Envs) > 0 { for _, e := range m.Envs { l = e.Size() n += 1 + l + sovApi(uint64(l)) } } if len(m.Mounts) > 0 { for _, e := range m.Mounts { l = e.Size() n += 1 + l + sovApi(uint64(l)) } } if len(m.Devices) > 0 { for _, e := range m.Devices { l = e.Size() n += 1 + l + sovApi(uint64(l)) } } if len(m.Labels) > 0 { for k, v := range m.Labels { _ = k _ = v mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + len(v) + sovApi(uint64(len(v))) n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) } } if len(m.Annotations) > 0 { for k, v := range m.Annotations { _ = k _ = v mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + len(v) + sovApi(uint64(len(v))) n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) } } l = len(m.LogPath) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.Stdin { n += 2 } if m.StdinOnce { n += 2 } if m.Tty { n += 2 } if m.Linux != nil { l = m.Linux.Size() n += 1 + l + sovApi(uint64(l)) } if m.Windows != nil { l = m.Windows.Size() n += 2 + l + sovApi(uint64(l)) } if len(m.CDIDevices) > 0 { for _, e := range m.CDIDevices { l = e.Size() n += 2 + l + sovApi(uint64(l)) } } return n } func (m *CreateContainerRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.PodSandboxId) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.Config != nil { l = m.Config.Size() n += 1 + l + sovApi(uint64(l)) } if m.SandboxConfig != nil { l = m.SandboxConfig.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *CreateContainerResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerId) if l > 0 { n += 1 + l + sovApi(uint64(l)) } return n } func (m *StartContainerRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerId) if l > 0 { n += 1 + l + sovApi(uint64(l)) } return n } func (m *StartContainerResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l return n } func (m *StopContainerRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerId) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.Timeout != 0 { n += 1 + sovApi(uint64(m.Timeout)) } return n } func (m *StopContainerResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l return n } func (m *RemoveContainerRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerId) if l > 0 { n += 1 + l + sovApi(uint64(l)) } return n } func (m *RemoveContainerResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l return n } func (m *ContainerStateValue) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.State != 0 { n += 1 + sovApi(uint64(m.State)) } return n } func (m *ContainerFilter) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Id) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.State != nil { l = m.State.Size() n += 1 + l + sovApi(uint64(l)) } l = len(m.PodSandboxId) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if len(m.LabelSelector) > 0 { for k, v := range m.LabelSelector { _ = k _ = v mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + len(v) + sovApi(uint64(len(v))) n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) } } return n } func (m *ListContainersRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Filter != nil { l = m.Filter.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *Container) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Id) if l > 0 { n += 1 + l + sovApi(uint64(l)) } l = len(m.PodSandboxId) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.Metadata != nil { l = m.Metadata.Size() n += 1 + l + sovApi(uint64(l)) } if m.Image != nil { l = m.Image.Size() n += 1 + l + sovApi(uint64(l)) } l = len(m.ImageRef) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.State != 0 { n += 1 + sovApi(uint64(m.State)) } if m.CreatedAt != 0 { n += 1 + sovApi(uint64(m.CreatedAt)) } if len(m.Labels) > 0 { for k, v := range m.Labels { _ = k _ = v mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + len(v) + sovApi(uint64(len(v))) n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) } } if len(m.Annotations) > 0 { for k, v := range m.Annotations { _ = k _ = v mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + len(v) + sovApi(uint64(len(v))) n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) } } l = len(m.ImageId) if l > 0 { n += 1 + l + sovApi(uint64(l)) } return n } func (m *ListContainersResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Containers) > 0 { for _, e := range m.Containers { l = e.Size() n += 1 + l + sovApi(uint64(l)) } } return n } func (m *ContainerStatusRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerId) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.Verbose { n += 2 } return n } func (m *ContainerStatus) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Id) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.Metadata != nil { l = m.Metadata.Size() n += 1 + l + sovApi(uint64(l)) } if m.State != 0 { n += 1 + sovApi(uint64(m.State)) } if m.CreatedAt != 0 { n += 1 + sovApi(uint64(m.CreatedAt)) } if m.StartedAt != 0 { n += 1 + sovApi(uint64(m.StartedAt)) } if m.FinishedAt != 0 { n += 1 + sovApi(uint64(m.FinishedAt)) } if m.ExitCode != 0 { n += 1 + sovApi(uint64(m.ExitCode)) } if m.Image != nil { l = m.Image.Size() n += 1 + l + sovApi(uint64(l)) } l = len(m.ImageRef) if l > 0 { n += 1 + l + sovApi(uint64(l)) } l = len(m.Reason) if l > 0 { n += 1 + l + sovApi(uint64(l)) } l = len(m.Message) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if len(m.Labels) > 0 { for k, v := range m.Labels { _ = k _ = v mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + len(v) + sovApi(uint64(len(v))) n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) } } if len(m.Annotations) > 0 { for k, v := range m.Annotations { _ = k _ = v mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + len(v) + sovApi(uint64(len(v))) n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) } } if len(m.Mounts) > 0 { for _, e := range m.Mounts { l = e.Size() n += 1 + l + sovApi(uint64(l)) } } l = len(m.LogPath) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.Resources != nil { 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 } func (m *ContainerStatusResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Status != nil { l = m.Status.Size() n += 1 + l + sovApi(uint64(l)) } if len(m.Info) > 0 { for k, v := range m.Info { _ = k _ = v mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + len(v) + sovApi(uint64(len(v))) n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) } } return n } func (m *ContainerResources) 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)) } if m.Windows != nil { l = m.Windows.Size() n += 1 + l + sovApi(uint64(l)) } 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 } var l int _ = l l = len(m.ContainerId) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.Linux != nil { l = m.Linux.Size() n += 1 + l + sovApi(uint64(l)) } if m.Windows != nil { l = m.Windows.Size() n += 1 + l + sovApi(uint64(l)) } if len(m.Annotations) > 0 { for k, v := range m.Annotations { _ = k _ = v mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + len(v) + sovApi(uint64(len(v))) n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) } } return n } func (m *UpdateContainerResourcesResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l return n } func (m *ExecSyncRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerId) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if len(m.Cmd) > 0 { for _, s := range m.Cmd { l = len(s) n += 1 + l + sovApi(uint64(l)) } } if m.Timeout != 0 { n += 1 + sovApi(uint64(m.Timeout)) } return n } func (m *ExecSyncResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Stdout) if l > 0 { n += 1 + l + sovApi(uint64(l)) } l = len(m.Stderr) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.ExitCode != 0 { n += 1 + sovApi(uint64(m.ExitCode)) } return n } func (m *ExecRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerId) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if len(m.Cmd) > 0 { for _, s := range m.Cmd { l = len(s) n += 1 + l + sovApi(uint64(l)) } } if m.Tty { n += 2 } if m.Stdin { n += 2 } if m.Stdout { n += 2 } if m.Stderr { n += 2 } return n } func (m *ExecResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Url) if l > 0 { n += 1 + l + sovApi(uint64(l)) } return n } func (m *AttachRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerId) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.Stdin { n += 2 } if m.Tty { n += 2 } if m.Stdout { n += 2 } if m.Stderr { n += 2 } return n } func (m *AttachResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Url) if l > 0 { n += 1 + l + sovApi(uint64(l)) } return n } func (m *PortForwardRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.PodSandboxId) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if len(m.Port) > 0 { l = 0 for _, e := range m.Port { l += sovApi(uint64(e)) } n += 1 + sovApi(uint64(l)) + l } return n } func (m *PortForwardResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Url) if l > 0 { n += 1 + l + sovApi(uint64(l)) } return n } func (m *ImageFilter) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Image != nil { l = m.Image.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *ListImagesRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Filter != nil { l = m.Filter.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *Image) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Id) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if len(m.RepoTags) > 0 { for _, s := range m.RepoTags { l = len(s) n += 1 + l + sovApi(uint64(l)) } } if len(m.RepoDigests) > 0 { for _, s := range m.RepoDigests { l = len(s) n += 1 + l + sovApi(uint64(l)) } } if m.Size_ != 0 { n += 1 + sovApi(uint64(m.Size_)) } if m.Uid != nil { l = m.Uid.Size() n += 1 + l + sovApi(uint64(l)) } l = len(m.Username) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.Spec != nil { l = m.Spec.Size() n += 1 + l + sovApi(uint64(l)) } if m.Pinned { n += 2 } return n } func (m *ListImagesResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Images) > 0 { for _, e := range m.Images { l = e.Size() n += 1 + l + sovApi(uint64(l)) } } return n } func (m *ImageStatusRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Image != nil { l = m.Image.Size() n += 1 + l + sovApi(uint64(l)) } if m.Verbose { n += 2 } return n } func (m *ImageStatusResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Image != nil { l = m.Image.Size() n += 1 + l + sovApi(uint64(l)) } if len(m.Info) > 0 { for k, v := range m.Info { _ = k _ = v mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + len(v) + sovApi(uint64(len(v))) n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) } } return n } func (m *AuthConfig) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Username) if l > 0 { n += 1 + l + sovApi(uint64(l)) } l = len(m.Password) if l > 0 { n += 1 + l + sovApi(uint64(l)) } l = len(m.Auth) if l > 0 { n += 1 + l + sovApi(uint64(l)) } l = len(m.ServerAddress) if l > 0 { n += 1 + l + sovApi(uint64(l)) } l = len(m.IdentityToken) if l > 0 { n += 1 + l + sovApi(uint64(l)) } l = len(m.RegistryToken) if l > 0 { n += 1 + l + sovApi(uint64(l)) } return n } func (m *PullImageRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Image != nil { l = m.Image.Size() n += 1 + l + sovApi(uint64(l)) } if m.Auth != nil { l = m.Auth.Size() n += 1 + l + sovApi(uint64(l)) } if m.SandboxConfig != nil { l = m.SandboxConfig.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *PullImageResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ImageRef) if l > 0 { n += 1 + l + sovApi(uint64(l)) } return n } func (m *RemoveImageRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Image != nil { l = m.Image.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *RemoveImageResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l return n } func (m *NetworkConfig) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.PodCidr) if l > 0 { n += 1 + l + sovApi(uint64(l)) } return n } func (m *RuntimeConfig) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.NetworkConfig != nil { l = m.NetworkConfig.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *UpdateRuntimeConfigRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.RuntimeConfig != nil { l = m.RuntimeConfig.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *UpdateRuntimeConfigResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l return n } func (m *RuntimeCondition) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Type) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.Status { n += 2 } l = len(m.Reason) if l > 0 { n += 1 + l + sovApi(uint64(l)) } l = len(m.Message) if l > 0 { n += 1 + l + sovApi(uint64(l)) } return n } func (m *RuntimeStatus) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Conditions) > 0 { for _, e := range m.Conditions { l = e.Size() n += 1 + l + sovApi(uint64(l)) } } return n } func (m *StatusRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Verbose { n += 2 } 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 } var l int _ = l if m.Status != nil { l = m.Status.Size() n += 1 + l + sovApi(uint64(l)) } if len(m.Info) > 0 { for k, v := range m.Info { _ = k _ = v mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + len(v) + sovApi(uint64(len(v))) 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 } func (m *ImageFsInfoRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l return n } func (m *UInt64Value) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Value != 0 { n += 1 + sovApi(uint64(m.Value)) } return n } func (m *FilesystemIdentifier) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Mountpoint) if l > 0 { n += 1 + l + sovApi(uint64(l)) } return n } func (m *FilesystemUsage) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Timestamp != 0 { n += 1 + sovApi(uint64(m.Timestamp)) } if m.FsId != nil { l = m.FsId.Size() n += 1 + l + sovApi(uint64(l)) } if m.UsedBytes != nil { l = m.UsedBytes.Size() n += 1 + l + sovApi(uint64(l)) } if m.InodesUsed != nil { l = m.InodesUsed.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *WindowsFilesystemUsage) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Timestamp != 0 { n += 1 + sovApi(uint64(m.Timestamp)) } if m.FsId != nil { l = m.FsId.Size() n += 1 + l + sovApi(uint64(l)) } if m.UsedBytes != nil { l = m.UsedBytes.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *ImageFsInfoResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.ImageFilesystems) > 0 { for _, e := range m.ImageFilesystems { l = e.Size() 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 } func (m *ContainerStatsRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerId) if l > 0 { n += 1 + l + sovApi(uint64(l)) } return n } func (m *ContainerStatsResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Stats != nil { l = m.Stats.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *ListContainerStatsRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Filter != nil { l = m.Filter.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *ContainerStatsFilter) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Id) if l > 0 { n += 1 + l + sovApi(uint64(l)) } l = len(m.PodSandboxId) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if len(m.LabelSelector) > 0 { for k, v := range m.LabelSelector { _ = k _ = v mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + len(v) + sovApi(uint64(len(v))) n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) } } return n } func (m *ListContainerStatsResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Stats) > 0 { for _, e := range m.Stats { l = e.Size() n += 1 + l + sovApi(uint64(l)) } } return n } func (m *ContainerAttributes) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.Id) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.Metadata != nil { l = m.Metadata.Size() n += 1 + l + sovApi(uint64(l)) } if len(m.Labels) > 0 { for k, v := range m.Labels { _ = k _ = v mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + len(v) + sovApi(uint64(len(v))) n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) } } if len(m.Annotations) > 0 { for k, v := range m.Annotations { _ = k _ = v mapEntrySize := 1 + len(k) + sovApi(uint64(len(k))) + 1 + len(v) + sovApi(uint64(len(v))) n += mapEntrySize + 1 + sovApi(uint64(mapEntrySize)) } } return n } func (m *ContainerStats) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Attributes != nil { l = m.Attributes.Size() n += 1 + l + sovApi(uint64(l)) } if m.Cpu != nil { l = m.Cpu.Size() n += 1 + l + sovApi(uint64(l)) } if m.Memory != nil { l = m.Memory.Size() n += 1 + l + sovApi(uint64(l)) } if m.WritableLayer != nil { 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 } func (m *WindowsContainerStats) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Attributes != nil { l = m.Attributes.Size() n += 1 + l + sovApi(uint64(l)) } if m.Cpu != nil { l = m.Cpu.Size() n += 1 + l + sovApi(uint64(l)) } if m.Memory != nil { l = m.Memory.Size() n += 1 + l + sovApi(uint64(l)) } if m.WritableLayer != nil { l = m.WritableLayer.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *CpuUsage) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Timestamp != 0 { n += 1 + sovApi(uint64(m.Timestamp)) } if m.UsageCoreNanoSeconds != nil { l = m.UsageCoreNanoSeconds.Size() n += 1 + l + sovApi(uint64(l)) } if m.UsageNanoCores != nil { l = m.UsageNanoCores.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *WindowsCpuUsage) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Timestamp != 0 { n += 1 + sovApi(uint64(m.Timestamp)) } if m.UsageCoreNanoSeconds != nil { l = m.UsageCoreNanoSeconds.Size() n += 1 + l + sovApi(uint64(l)) } if m.UsageNanoCores != nil { l = m.UsageNanoCores.Size() n += 1 + l + sovApi(uint64(l)) } return n } func (m *MemoryUsage) Size() (n int) { if m == nil { return 0 } var l int _ = l if m.Timestamp != 0 { n += 1 + sovApi(uint64(m.Timestamp)) } if m.WorkingSetBytes != nil { l = m.WorkingSetBytes.Size() n += 1 + l + sovApi(uint64(l)) } if m.AvailableBytes != nil { l = m.AvailableBytes.Size() n += 1 + l + sovApi(uint64(l)) } if m.UsageBytes != nil { l = m.UsageBytes.Size() n += 1 + l + sovApi(uint64(l)) } if m.RssBytes != nil { l = m.RssBytes.Size() n += 1 + l + sovApi(uint64(l)) } if m.PageFaults != nil { l = m.PageFaults.Size() n += 1 + l + sovApi(uint64(l)) } if m.MajorPageFaults != nil { l = m.MajorPageFaults.Size() n += 1 + l + sovApi(uint64(l)) } 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 } var l int _ = l if m.Timestamp != 0 { n += 1 + sovApi(uint64(m.Timestamp)) } if m.WorkingSetBytes != nil { l = m.WorkingSetBytes.Size() n += 1 + l + sovApi(uint64(l)) } if m.AvailableBytes != nil { l = m.AvailableBytes.Size() n += 1 + l + sovApi(uint64(l)) } if m.PageFaults != nil { 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 } func (m *ReopenContainerLogRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerId) if l > 0 { n += 1 + l + sovApi(uint64(l)) } return n } func (m *ReopenContainerLogResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l return n } func (m *CheckpointContainerRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerId) if l > 0 { n += 1 + l + sovApi(uint64(l)) } l = len(m.Location) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.Timeout != 0 { n += 1 + sovApi(uint64(m.Timeout)) } return n } func (m *CheckpointContainerResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l return n } func (m *GetEventsRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l return n } func (m *ContainerEventResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerId) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if m.ContainerEventType != 0 { n += 1 + sovApi(uint64(m.ContainerEventType)) } if m.CreatedAt != 0 { n += 1 + sovApi(uint64(m.CreatedAt)) } if m.PodSandboxStatus != nil { l = m.PodSandboxStatus.Size() n += 1 + l + sovApi(uint64(l)) } if len(m.ContainersStatuses) > 0 { for _, e := range m.ContainersStatuses { l = e.Size() n += 1 + l + sovApi(uint64(l)) } } return n } func (m *ListMetricDescriptorsRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l return n } func (m *ListMetricDescriptorsResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.Descriptors) > 0 { for _, e := range m.Descriptors { l = e.Size() n += 1 + l + sovApi(uint64(l)) } } return n } func (m *MetricDescriptor) 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)) } l = len(m.Help) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if len(m.LabelKeys) > 0 { for _, s := range m.LabelKeys { l = len(s) n += 1 + l + sovApi(uint64(l)) } } return n } func (m *ListPodSandboxMetricsRequest) Size() (n int) { if m == nil { return 0 } var l int _ = l return n } func (m *ListPodSandboxMetricsResponse) Size() (n int) { if m == nil { return 0 } var l int _ = l if len(m.PodMetrics) > 0 { for _, e := range m.PodMetrics { l = e.Size() n += 1 + l + sovApi(uint64(l)) } } return n } func (m *PodSandboxMetrics) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.PodSandboxId) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if len(m.Metrics) > 0 { for _, e := range m.Metrics { l = e.Size() n += 1 + l + sovApi(uint64(l)) } } if len(m.ContainerMetrics) > 0 { for _, e := range m.ContainerMetrics { l = e.Size() n += 1 + l + sovApi(uint64(l)) } } return n } func (m *ContainerMetrics) Size() (n int) { if m == nil { return 0 } var l int _ = l l = len(m.ContainerId) if l > 0 { n += 1 + l + sovApi(uint64(l)) } if len(m.Metrics) > 0 { for _, e := range m.Metrics { l = e.Size() n += 1 + l + sovApi(uint64(l)) } } return n } func (m *Metric) 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.Timestamp != 0 { n += 1 + sovApi(uint64(m.Timestamp)) } if m.MetricType != 0 { n += 1 + sovApi(uint64(m.MetricType)) } if len(m.LabelValues) > 0 { for _, s := range m.LabelValues { l = len(s) n += 1 + l + sovApi(uint64(l)) } } if m.Value != nil { l = m.Value.Size() n += 1 + l + sovApi(uint64(l)) } 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 } func sozApi(x uint64) (n int) { return sovApi(uint64((x << 1) ^ uint64((int64(x) >> 63)))) } func (this *VersionRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&VersionRequest{`, `Version:` + fmt.Sprintf("%v", this.Version) + `,`, `}`, }, "") return s } func (this *VersionResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&VersionResponse{`, `Version:` + fmt.Sprintf("%v", this.Version) + `,`, `RuntimeName:` + fmt.Sprintf("%v", this.RuntimeName) + `,`, `RuntimeVersion:` + fmt.Sprintf("%v", this.RuntimeVersion) + `,`, `RuntimeApiVersion:` + fmt.Sprintf("%v", this.RuntimeApiVersion) + `,`, `}`, }, "") return s } func (this *DNSConfig) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&DNSConfig{`, `Servers:` + fmt.Sprintf("%v", this.Servers) + `,`, `Searches:` + fmt.Sprintf("%v", this.Searches) + `,`, `Options:` + fmt.Sprintf("%v", this.Options) + `,`, `}`, }, "") return s } func (this *PortMapping) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&PortMapping{`, `Protocol:` + fmt.Sprintf("%v", this.Protocol) + `,`, `ContainerPort:` + fmt.Sprintf("%v", this.ContainerPort) + `,`, `HostPort:` + fmt.Sprintf("%v", this.HostPort) + `,`, `HostIp:` + fmt.Sprintf("%v", this.HostIp) + `,`, `}`, }, "") return s } func (this *Mount) String() string { if this == nil { return "nil" } repeatedStringForUidMappings := "[]*IDMapping{" for _, f := range this.UidMappings { repeatedStringForUidMappings += strings.Replace(f.String(), "IDMapping", "IDMapping", 1) + "," } repeatedStringForUidMappings += "}" repeatedStringForGidMappings := "[]*IDMapping{" for _, f := range this.GidMappings { repeatedStringForGidMappings += strings.Replace(f.String(), "IDMapping", "IDMapping", 1) + "," } repeatedStringForGidMappings += "}" s := strings.Join([]string{`&Mount{`, `ContainerPath:` + fmt.Sprintf("%v", this.ContainerPath) + `,`, `HostPath:` + fmt.Sprintf("%v", this.HostPath) + `,`, `Readonly:` + fmt.Sprintf("%v", this.Readonly) + `,`, `SelinuxRelabel:` + fmt.Sprintf("%v", this.SelinuxRelabel) + `,`, `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 } func (this *IDMapping) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&IDMapping{`, `HostId:` + fmt.Sprintf("%v", this.HostId) + `,`, `ContainerId:` + fmt.Sprintf("%v", this.ContainerId) + `,`, `Length:` + fmt.Sprintf("%v", this.Length) + `,`, `}`, }, "") return s } func (this *UserNamespace) String() string { if this == nil { return "nil" } repeatedStringForUids := "[]*IDMapping{" for _, f := range this.Uids { repeatedStringForUids += strings.Replace(f.String(), "IDMapping", "IDMapping", 1) + "," } repeatedStringForUids += "}" repeatedStringForGids := "[]*IDMapping{" for _, f := range this.Gids { repeatedStringForGids += strings.Replace(f.String(), "IDMapping", "IDMapping", 1) + "," } repeatedStringForGids += "}" s := strings.Join([]string{`&UserNamespace{`, `Mode:` + fmt.Sprintf("%v", this.Mode) + `,`, `Uids:` + repeatedStringForUids + `,`, `Gids:` + repeatedStringForGids + `,`, `}`, }, "") return s } func (this *NamespaceOption) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&NamespaceOption{`, `Network:` + fmt.Sprintf("%v", this.Network) + `,`, `Pid:` + fmt.Sprintf("%v", this.Pid) + `,`, `Ipc:` + fmt.Sprintf("%v", this.Ipc) + `,`, `TargetId:` + fmt.Sprintf("%v", this.TargetId) + `,`, `UsernsOptions:` + strings.Replace(this.UsernsOptions.String(), "UserNamespace", "UserNamespace", 1) + `,`, `}`, }, "") return s } func (this *Int64Value) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&Int64Value{`, `Value:` + fmt.Sprintf("%v", this.Value) + `,`, `}`, }, "") return s } func (this *LinuxSandboxSecurityContext) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&LinuxSandboxSecurityContext{`, `NamespaceOptions:` + strings.Replace(this.NamespaceOptions.String(), "NamespaceOption", "NamespaceOption", 1) + `,`, `SelinuxOptions:` + strings.Replace(this.SelinuxOptions.String(), "SELinuxOption", "SELinuxOption", 1) + `,`, `RunAsUser:` + strings.Replace(this.RunAsUser.String(), "Int64Value", "Int64Value", 1) + `,`, `ReadonlyRootfs:` + fmt.Sprintf("%v", this.ReadonlyRootfs) + `,`, `SupplementalGroups:` + fmt.Sprintf("%v", this.SupplementalGroups) + `,`, `Privileged:` + fmt.Sprintf("%v", this.Privileged) + `,`, `SeccompProfilePath:` + fmt.Sprintf("%v", this.SeccompProfilePath) + `,`, `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 } func (this *SecurityProfile) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&SecurityProfile{`, `ProfileType:` + fmt.Sprintf("%v", this.ProfileType) + `,`, `LocalhostRef:` + fmt.Sprintf("%v", this.LocalhostRef) + `,`, `}`, }, "") return s } func (this *LinuxPodSandboxConfig) String() string { if this == nil { return "nil" } keysForSysctls := make([]string, 0, len(this.Sysctls)) for k := range this.Sysctls { keysForSysctls = append(keysForSysctls, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForSysctls) mapStringForSysctls := "map[string]string{" for _, k := range keysForSysctls { mapStringForSysctls += fmt.Sprintf("%v: %v,", k, this.Sysctls[k]) } mapStringForSysctls += "}" s := strings.Join([]string{`&LinuxPodSandboxConfig{`, `CgroupParent:` + fmt.Sprintf("%v", this.CgroupParent) + `,`, `SecurityContext:` + strings.Replace(this.SecurityContext.String(), "LinuxSandboxSecurityContext", "LinuxSandboxSecurityContext", 1) + `,`, `Sysctls:` + mapStringForSysctls + `,`, `Overhead:` + strings.Replace(this.Overhead.String(), "LinuxContainerResources", "LinuxContainerResources", 1) + `,`, `Resources:` + strings.Replace(this.Resources.String(), "LinuxContainerResources", "LinuxContainerResources", 1) + `,`, `}`, }, "") return s } func (this *PodSandboxMetadata) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&PodSandboxMetadata{`, `Name:` + fmt.Sprintf("%v", this.Name) + `,`, `Uid:` + fmt.Sprintf("%v", this.Uid) + `,`, `Namespace:` + fmt.Sprintf("%v", this.Namespace) + `,`, `Attempt:` + fmt.Sprintf("%v", this.Attempt) + `,`, `}`, }, "") return s } func (this *PodSandboxConfig) String() string { if this == nil { return "nil" } repeatedStringForPortMappings := "[]*PortMapping{" for _, f := range this.PortMappings { repeatedStringForPortMappings += strings.Replace(f.String(), "PortMapping", "PortMapping", 1) + "," } repeatedStringForPortMappings += "}" keysForLabels := make([]string, 0, len(this.Labels)) for k := range this.Labels { keysForLabels = append(keysForLabels, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) mapStringForLabels := "map[string]string{" for _, k := range keysForLabels { mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) } mapStringForLabels += "}" keysForAnnotations := make([]string, 0, len(this.Annotations)) for k := range this.Annotations { keysForAnnotations = append(keysForAnnotations, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations) mapStringForAnnotations := "map[string]string{" for _, k := range keysForAnnotations { mapStringForAnnotations += fmt.Sprintf("%v: %v,", k, this.Annotations[k]) } mapStringForAnnotations += "}" s := strings.Join([]string{`&PodSandboxConfig{`, `Metadata:` + strings.Replace(this.Metadata.String(), "PodSandboxMetadata", "PodSandboxMetadata", 1) + `,`, `Hostname:` + fmt.Sprintf("%v", this.Hostname) + `,`, `LogDirectory:` + fmt.Sprintf("%v", this.LogDirectory) + `,`, `DnsConfig:` + strings.Replace(this.DnsConfig.String(), "DNSConfig", "DNSConfig", 1) + `,`, `PortMappings:` + repeatedStringForPortMappings + `,`, `Labels:` + mapStringForLabels + `,`, `Annotations:` + mapStringForAnnotations + `,`, `Linux:` + strings.Replace(this.Linux.String(), "LinuxPodSandboxConfig", "LinuxPodSandboxConfig", 1) + `,`, `Windows:` + strings.Replace(this.Windows.String(), "WindowsPodSandboxConfig", "WindowsPodSandboxConfig", 1) + `,`, `}`, }, "") return s } func (this *RunPodSandboxRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&RunPodSandboxRequest{`, `Config:` + strings.Replace(this.Config.String(), "PodSandboxConfig", "PodSandboxConfig", 1) + `,`, `RuntimeHandler:` + fmt.Sprintf("%v", this.RuntimeHandler) + `,`, `}`, }, "") return s } func (this *RunPodSandboxResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&RunPodSandboxResponse{`, `PodSandboxId:` + fmt.Sprintf("%v", this.PodSandboxId) + `,`, `}`, }, "") return s } func (this *StopPodSandboxRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&StopPodSandboxRequest{`, `PodSandboxId:` + fmt.Sprintf("%v", this.PodSandboxId) + `,`, `}`, }, "") return s } func (this *StopPodSandboxResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&StopPodSandboxResponse{`, `}`, }, "") return s } func (this *RemovePodSandboxRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&RemovePodSandboxRequest{`, `PodSandboxId:` + fmt.Sprintf("%v", this.PodSandboxId) + `,`, `}`, }, "") return s } func (this *RemovePodSandboxResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&RemovePodSandboxResponse{`, `}`, }, "") return s } func (this *PodSandboxStatusRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&PodSandboxStatusRequest{`, `PodSandboxId:` + fmt.Sprintf("%v", this.PodSandboxId) + `,`, `Verbose:` + fmt.Sprintf("%v", this.Verbose) + `,`, `}`, }, "") return s } func (this *PodIP) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&PodIP{`, `Ip:` + fmt.Sprintf("%v", this.Ip) + `,`, `}`, }, "") return s } func (this *PodSandboxNetworkStatus) String() string { if this == nil { return "nil" } repeatedStringForAdditionalIps := "[]*PodIP{" for _, f := range this.AdditionalIps { repeatedStringForAdditionalIps += strings.Replace(f.String(), "PodIP", "PodIP", 1) + "," } repeatedStringForAdditionalIps += "}" s := strings.Join([]string{`&PodSandboxNetworkStatus{`, `Ip:` + fmt.Sprintf("%v", this.Ip) + `,`, `AdditionalIps:` + repeatedStringForAdditionalIps + `,`, `}`, }, "") return s } func (this *Namespace) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&Namespace{`, `Options:` + strings.Replace(this.Options.String(), "NamespaceOption", "NamespaceOption", 1) + `,`, `}`, }, "") return s } func (this *LinuxPodSandboxStatus) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&LinuxPodSandboxStatus{`, `Namespaces:` + strings.Replace(this.Namespaces.String(), "Namespace", "Namespace", 1) + `,`, `}`, }, "") return s } func (this *PodSandboxStatus) String() string { if this == nil { return "nil" } keysForLabels := make([]string, 0, len(this.Labels)) for k := range this.Labels { keysForLabels = append(keysForLabels, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) mapStringForLabels := "map[string]string{" for _, k := range keysForLabels { mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) } mapStringForLabels += "}" keysForAnnotations := make([]string, 0, len(this.Annotations)) for k := range this.Annotations { keysForAnnotations = append(keysForAnnotations, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations) mapStringForAnnotations := "map[string]string{" for _, k := range keysForAnnotations { mapStringForAnnotations += fmt.Sprintf("%v: %v,", k, this.Annotations[k]) } mapStringForAnnotations += "}" s := strings.Join([]string{`&PodSandboxStatus{`, `Id:` + fmt.Sprintf("%v", this.Id) + `,`, `Metadata:` + strings.Replace(this.Metadata.String(), "PodSandboxMetadata", "PodSandboxMetadata", 1) + `,`, `State:` + fmt.Sprintf("%v", this.State) + `,`, `CreatedAt:` + fmt.Sprintf("%v", this.CreatedAt) + `,`, `Network:` + strings.Replace(this.Network.String(), "PodSandboxNetworkStatus", "PodSandboxNetworkStatus", 1) + `,`, `Linux:` + strings.Replace(this.Linux.String(), "LinuxPodSandboxStatus", "LinuxPodSandboxStatus", 1) + `,`, `Labels:` + mapStringForLabels + `,`, `Annotations:` + mapStringForAnnotations + `,`, `RuntimeHandler:` + fmt.Sprintf("%v", this.RuntimeHandler) + `,`, `}`, }, "") return s } func (this *PodSandboxStatusResponse) String() string { if this == nil { return "nil" } repeatedStringForContainersStatuses := "[]*ContainerStatus{" for _, f := range this.ContainersStatuses { repeatedStringForContainersStatuses += strings.Replace(f.String(), "ContainerStatus", "ContainerStatus", 1) + "," } repeatedStringForContainersStatuses += "}" keysForInfo := make([]string, 0, len(this.Info)) for k := range this.Info { keysForInfo = append(keysForInfo, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForInfo) mapStringForInfo := "map[string]string{" for _, k := range keysForInfo { mapStringForInfo += fmt.Sprintf("%v: %v,", k, this.Info[k]) } mapStringForInfo += "}" s := strings.Join([]string{`&PodSandboxStatusResponse{`, `Status:` + strings.Replace(this.Status.String(), "PodSandboxStatus", "PodSandboxStatus", 1) + `,`, `Info:` + mapStringForInfo + `,`, `ContainersStatuses:` + repeatedStringForContainersStatuses + `,`, `Timestamp:` + fmt.Sprintf("%v", this.Timestamp) + `,`, `}`, }, "") return s } func (this *PodSandboxStateValue) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&PodSandboxStateValue{`, `State:` + fmt.Sprintf("%v", this.State) + `,`, `}`, }, "") return s } func (this *PodSandboxFilter) String() string { if this == nil { return "nil" } keysForLabelSelector := make([]string, 0, len(this.LabelSelector)) for k := range this.LabelSelector { keysForLabelSelector = append(keysForLabelSelector, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForLabelSelector) mapStringForLabelSelector := "map[string]string{" for _, k := range keysForLabelSelector { mapStringForLabelSelector += fmt.Sprintf("%v: %v,", k, this.LabelSelector[k]) } mapStringForLabelSelector += "}" s := strings.Join([]string{`&PodSandboxFilter{`, `Id:` + fmt.Sprintf("%v", this.Id) + `,`, `State:` + strings.Replace(this.State.String(), "PodSandboxStateValue", "PodSandboxStateValue", 1) + `,`, `LabelSelector:` + mapStringForLabelSelector + `,`, `}`, }, "") return s } func (this *ListPodSandboxRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ListPodSandboxRequest{`, `Filter:` + strings.Replace(this.Filter.String(), "PodSandboxFilter", "PodSandboxFilter", 1) + `,`, `}`, }, "") return s } func (this *PodSandbox) String() string { if this == nil { return "nil" } keysForLabels := make([]string, 0, len(this.Labels)) for k := range this.Labels { keysForLabels = append(keysForLabels, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) mapStringForLabels := "map[string]string{" for _, k := range keysForLabels { mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) } mapStringForLabels += "}" keysForAnnotations := make([]string, 0, len(this.Annotations)) for k := range this.Annotations { keysForAnnotations = append(keysForAnnotations, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations) mapStringForAnnotations := "map[string]string{" for _, k := range keysForAnnotations { mapStringForAnnotations += fmt.Sprintf("%v: %v,", k, this.Annotations[k]) } mapStringForAnnotations += "}" s := strings.Join([]string{`&PodSandbox{`, `Id:` + fmt.Sprintf("%v", this.Id) + `,`, `Metadata:` + strings.Replace(this.Metadata.String(), "PodSandboxMetadata", "PodSandboxMetadata", 1) + `,`, `State:` + fmt.Sprintf("%v", this.State) + `,`, `CreatedAt:` + fmt.Sprintf("%v", this.CreatedAt) + `,`, `Labels:` + mapStringForLabels + `,`, `Annotations:` + mapStringForAnnotations + `,`, `RuntimeHandler:` + fmt.Sprintf("%v", this.RuntimeHandler) + `,`, `}`, }, "") return s } func (this *ListPodSandboxResponse) String() string { if this == nil { return "nil" } repeatedStringForItems := "[]*PodSandbox{" for _, f := range this.Items { repeatedStringForItems += strings.Replace(f.String(), "PodSandbox", "PodSandbox", 1) + "," } repeatedStringForItems += "}" s := strings.Join([]string{`&ListPodSandboxResponse{`, `Items:` + repeatedStringForItems + `,`, `}`, }, "") return s } func (this *PodSandboxStatsRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&PodSandboxStatsRequest{`, `PodSandboxId:` + fmt.Sprintf("%v", this.PodSandboxId) + `,`, `}`, }, "") return s } func (this *PodSandboxStatsResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&PodSandboxStatsResponse{`, `Stats:` + strings.Replace(this.Stats.String(), "PodSandboxStats", "PodSandboxStats", 1) + `,`, `}`, }, "") return s } func (this *PodSandboxStatsFilter) String() string { if this == nil { return "nil" } keysForLabelSelector := make([]string, 0, len(this.LabelSelector)) for k := range this.LabelSelector { keysForLabelSelector = append(keysForLabelSelector, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForLabelSelector) mapStringForLabelSelector := "map[string]string{" for _, k := range keysForLabelSelector { mapStringForLabelSelector += fmt.Sprintf("%v: %v,", k, this.LabelSelector[k]) } mapStringForLabelSelector += "}" s := strings.Join([]string{`&PodSandboxStatsFilter{`, `Id:` + fmt.Sprintf("%v", this.Id) + `,`, `LabelSelector:` + mapStringForLabelSelector + `,`, `}`, }, "") return s } func (this *ListPodSandboxStatsRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ListPodSandboxStatsRequest{`, `Filter:` + strings.Replace(this.Filter.String(), "PodSandboxStatsFilter", "PodSandboxStatsFilter", 1) + `,`, `}`, }, "") return s } func (this *ListPodSandboxStatsResponse) String() string { if this == nil { return "nil" } repeatedStringForStats := "[]*PodSandboxStats{" for _, f := range this.Stats { repeatedStringForStats += strings.Replace(f.String(), "PodSandboxStats", "PodSandboxStats", 1) + "," } repeatedStringForStats += "}" s := strings.Join([]string{`&ListPodSandboxStatsResponse{`, `Stats:` + repeatedStringForStats + `,`, `}`, }, "") return s } func (this *PodSandboxAttributes) String() string { if this == nil { return "nil" } keysForLabels := make([]string, 0, len(this.Labels)) for k := range this.Labels { keysForLabels = append(keysForLabels, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) mapStringForLabels := "map[string]string{" for _, k := range keysForLabels { mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) } mapStringForLabels += "}" keysForAnnotations := make([]string, 0, len(this.Annotations)) for k := range this.Annotations { keysForAnnotations = append(keysForAnnotations, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations) mapStringForAnnotations := "map[string]string{" for _, k := range keysForAnnotations { mapStringForAnnotations += fmt.Sprintf("%v: %v,", k, this.Annotations[k]) } mapStringForAnnotations += "}" s := strings.Join([]string{`&PodSandboxAttributes{`, `Id:` + fmt.Sprintf("%v", this.Id) + `,`, `Metadata:` + strings.Replace(this.Metadata.String(), "PodSandboxMetadata", "PodSandboxMetadata", 1) + `,`, `Labels:` + mapStringForLabels + `,`, `Annotations:` + mapStringForAnnotations + `,`, `}`, }, "") return s } func (this *PodSandboxStats) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&PodSandboxStats{`, `Attributes:` + strings.Replace(this.Attributes.String(), "PodSandboxAttributes", "PodSandboxAttributes", 1) + `,`, `Linux:` + strings.Replace(this.Linux.String(), "LinuxPodSandboxStats", "LinuxPodSandboxStats", 1) + `,`, `Windows:` + strings.Replace(this.Windows.String(), "WindowsPodSandboxStats", "WindowsPodSandboxStats", 1) + `,`, `}`, }, "") return s } func (this *LinuxPodSandboxStats) String() string { if this == nil { return "nil" } repeatedStringForContainers := "[]*ContainerStats{" for _, f := range this.Containers { repeatedStringForContainers += strings.Replace(f.String(), "ContainerStats", "ContainerStats", 1) + "," } repeatedStringForContainers += "}" s := strings.Join([]string{`&LinuxPodSandboxStats{`, `Cpu:` + strings.Replace(this.Cpu.String(), "CpuUsage", "CpuUsage", 1) + `,`, `Memory:` + strings.Replace(this.Memory.String(), "MemoryUsage", "MemoryUsage", 1) + `,`, `Network:` + strings.Replace(this.Network.String(), "NetworkUsage", "NetworkUsage", 1) + `,`, `Process:` + strings.Replace(this.Process.String(), "ProcessUsage", "ProcessUsage", 1) + `,`, `Containers:` + repeatedStringForContainers + `,`, `}`, }, "") return s } func (this *WindowsPodSandboxStats) String() string { if this == nil { return "nil" } repeatedStringForContainers := "[]*WindowsContainerStats{" for _, f := range this.Containers { repeatedStringForContainers += strings.Replace(f.String(), "WindowsContainerStats", "WindowsContainerStats", 1) + "," } repeatedStringForContainers += "}" s := strings.Join([]string{`&WindowsPodSandboxStats{`, `Cpu:` + strings.Replace(this.Cpu.String(), "WindowsCpuUsage", "WindowsCpuUsage", 1) + `,`, `Memory:` + strings.Replace(this.Memory.String(), "WindowsMemoryUsage", "WindowsMemoryUsage", 1) + `,`, `Network:` + strings.Replace(this.Network.String(), "WindowsNetworkUsage", "WindowsNetworkUsage", 1) + `,`, `Process:` + strings.Replace(this.Process.String(), "WindowsProcessUsage", "WindowsProcessUsage", 1) + `,`, `Containers:` + repeatedStringForContainers + `,`, `}`, }, "") return s } func (this *NetworkUsage) String() string { if this == nil { return "nil" } repeatedStringForInterfaces := "[]*NetworkInterfaceUsage{" for _, f := range this.Interfaces { repeatedStringForInterfaces += strings.Replace(f.String(), "NetworkInterfaceUsage", "NetworkInterfaceUsage", 1) + "," } repeatedStringForInterfaces += "}" s := strings.Join([]string{`&NetworkUsage{`, `Timestamp:` + fmt.Sprintf("%v", this.Timestamp) + `,`, `DefaultInterface:` + strings.Replace(this.DefaultInterface.String(), "NetworkInterfaceUsage", "NetworkInterfaceUsage", 1) + `,`, `Interfaces:` + repeatedStringForInterfaces + `,`, `}`, }, "") return s } func (this *WindowsNetworkUsage) String() string { if this == nil { return "nil" } repeatedStringForInterfaces := "[]*WindowsNetworkInterfaceUsage{" for _, f := range this.Interfaces { repeatedStringForInterfaces += strings.Replace(f.String(), "WindowsNetworkInterfaceUsage", "WindowsNetworkInterfaceUsage", 1) + "," } repeatedStringForInterfaces += "}" s := strings.Join([]string{`&WindowsNetworkUsage{`, `Timestamp:` + fmt.Sprintf("%v", this.Timestamp) + `,`, `DefaultInterface:` + strings.Replace(this.DefaultInterface.String(), "WindowsNetworkInterfaceUsage", "WindowsNetworkInterfaceUsage", 1) + `,`, `Interfaces:` + repeatedStringForInterfaces + `,`, `}`, }, "") return s } func (this *NetworkInterfaceUsage) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&NetworkInterfaceUsage{`, `Name:` + fmt.Sprintf("%v", this.Name) + `,`, `RxBytes:` + strings.Replace(this.RxBytes.String(), "UInt64Value", "UInt64Value", 1) + `,`, `RxErrors:` + strings.Replace(this.RxErrors.String(), "UInt64Value", "UInt64Value", 1) + `,`, `TxBytes:` + strings.Replace(this.TxBytes.String(), "UInt64Value", "UInt64Value", 1) + `,`, `TxErrors:` + strings.Replace(this.TxErrors.String(), "UInt64Value", "UInt64Value", 1) + `,`, `}`, }, "") return s } func (this *WindowsNetworkInterfaceUsage) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&WindowsNetworkInterfaceUsage{`, `Name:` + fmt.Sprintf("%v", this.Name) + `,`, `RxBytes:` + strings.Replace(this.RxBytes.String(), "UInt64Value", "UInt64Value", 1) + `,`, `RxPacketsDropped:` + strings.Replace(this.RxPacketsDropped.String(), "UInt64Value", "UInt64Value", 1) + `,`, `TxBytes:` + strings.Replace(this.TxBytes.String(), "UInt64Value", "UInt64Value", 1) + `,`, `TxPacketsDropped:` + strings.Replace(this.TxPacketsDropped.String(), "UInt64Value", "UInt64Value", 1) + `,`, `}`, }, "") return s } func (this *ProcessUsage) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ProcessUsage{`, `Timestamp:` + fmt.Sprintf("%v", this.Timestamp) + `,`, `ProcessCount:` + strings.Replace(this.ProcessCount.String(), "UInt64Value", "UInt64Value", 1) + `,`, `}`, }, "") return s } func (this *WindowsProcessUsage) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&WindowsProcessUsage{`, `Timestamp:` + fmt.Sprintf("%v", this.Timestamp) + `,`, `ProcessCount:` + strings.Replace(this.ProcessCount.String(), "UInt64Value", "UInt64Value", 1) + `,`, `}`, }, "") return s } func (this *ImageSpec) String() string { if this == nil { return "nil" } keysForAnnotations := make([]string, 0, len(this.Annotations)) for k := range this.Annotations { keysForAnnotations = append(keysForAnnotations, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations) mapStringForAnnotations := "map[string]string{" for _, k := range keysForAnnotations { mapStringForAnnotations += fmt.Sprintf("%v: %v,", k, this.Annotations[k]) } mapStringForAnnotations += "}" 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 } func (this *KeyValue) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&KeyValue{`, `Key:` + fmt.Sprintf("%v", this.Key) + `,`, `Value:` + fmt.Sprintf("%v", this.Value) + `,`, `}`, }, "") return s } func (this *LinuxContainerResources) String() string { if this == nil { return "nil" } repeatedStringForHugepageLimits := "[]*HugepageLimit{" for _, f := range this.HugepageLimits { repeatedStringForHugepageLimits += strings.Replace(f.String(), "HugepageLimit", "HugepageLimit", 1) + "," } repeatedStringForHugepageLimits += "}" keysForUnified := make([]string, 0, len(this.Unified)) for k := range this.Unified { keysForUnified = append(keysForUnified, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForUnified) mapStringForUnified := "map[string]string{" for _, k := range keysForUnified { mapStringForUnified += fmt.Sprintf("%v: %v,", k, this.Unified[k]) } mapStringForUnified += "}" s := strings.Join([]string{`&LinuxContainerResources{`, `CpuPeriod:` + fmt.Sprintf("%v", this.CpuPeriod) + `,`, `CpuQuota:` + fmt.Sprintf("%v", this.CpuQuota) + `,`, `CpuShares:` + fmt.Sprintf("%v", this.CpuShares) + `,`, `MemoryLimitInBytes:` + fmt.Sprintf("%v", this.MemoryLimitInBytes) + `,`, `OomScoreAdj:` + fmt.Sprintf("%v", this.OomScoreAdj) + `,`, `CpusetCpus:` + fmt.Sprintf("%v", this.CpusetCpus) + `,`, `CpusetMems:` + fmt.Sprintf("%v", this.CpusetMems) + `,`, `HugepageLimits:` + repeatedStringForHugepageLimits + `,`, `Unified:` + mapStringForUnified + `,`, `MemorySwapLimitInBytes:` + fmt.Sprintf("%v", this.MemorySwapLimitInBytes) + `,`, `}`, }, "") return s } func (this *HugepageLimit) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&HugepageLimit{`, `PageSize:` + fmt.Sprintf("%v", this.PageSize) + `,`, `Limit:` + fmt.Sprintf("%v", this.Limit) + `,`, `}`, }, "") return s } func (this *SELinuxOption) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&SELinuxOption{`, `User:` + fmt.Sprintf("%v", this.User) + `,`, `Role:` + fmt.Sprintf("%v", this.Role) + `,`, `Type:` + fmt.Sprintf("%v", this.Type) + `,`, `Level:` + fmt.Sprintf("%v", this.Level) + `,`, `}`, }, "") return s } func (this *Capability) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&Capability{`, `AddCapabilities:` + fmt.Sprintf("%v", this.AddCapabilities) + `,`, `DropCapabilities:` + fmt.Sprintf("%v", this.DropCapabilities) + `,`, `AddAmbientCapabilities:` + fmt.Sprintf("%v", this.AddAmbientCapabilities) + `,`, `}`, }, "") return s } func (this *LinuxContainerSecurityContext) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&LinuxContainerSecurityContext{`, `Capabilities:` + strings.Replace(this.Capabilities.String(), "Capability", "Capability", 1) + `,`, `Privileged:` + fmt.Sprintf("%v", this.Privileged) + `,`, `NamespaceOptions:` + strings.Replace(this.NamespaceOptions.String(), "NamespaceOption", "NamespaceOption", 1) + `,`, `SelinuxOptions:` + strings.Replace(this.SelinuxOptions.String(), "SELinuxOption", "SELinuxOption", 1) + `,`, `RunAsUser:` + strings.Replace(this.RunAsUser.String(), "Int64Value", "Int64Value", 1) + `,`, `RunAsUsername:` + fmt.Sprintf("%v", this.RunAsUsername) + `,`, `ReadonlyRootfs:` + fmt.Sprintf("%v", this.ReadonlyRootfs) + `,`, `SupplementalGroups:` + fmt.Sprintf("%v", this.SupplementalGroups) + `,`, `ApparmorProfile:` + fmt.Sprintf("%v", this.ApparmorProfile) + `,`, `SeccompProfilePath:` + fmt.Sprintf("%v", this.SeccompProfilePath) + `,`, `NoNewPrivs:` + fmt.Sprintf("%v", this.NoNewPrivs) + `,`, `RunAsGroup:` + strings.Replace(this.RunAsGroup.String(), "Int64Value", "Int64Value", 1) + `,`, `MaskedPaths:` + fmt.Sprintf("%v", this.MaskedPaths) + `,`, `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 } func (this *LinuxContainerConfig) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&LinuxContainerConfig{`, `Resources:` + strings.Replace(this.Resources.String(), "LinuxContainerResources", "LinuxContainerResources", 1) + `,`, `SecurityContext:` + strings.Replace(this.SecurityContext.String(), "LinuxContainerSecurityContext", "LinuxContainerSecurityContext", 1) + `,`, `}`, }, "") 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" } s := strings.Join([]string{`&WindowsNamespaceOption{`, `Network:` + fmt.Sprintf("%v", this.Network) + `,`, `}`, }, "") return s } func (this *WindowsSandboxSecurityContext) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&WindowsSandboxSecurityContext{`, `RunAsUsername:` + fmt.Sprintf("%v", this.RunAsUsername) + `,`, `CredentialSpec:` + fmt.Sprintf("%v", this.CredentialSpec) + `,`, `HostProcess:` + fmt.Sprintf("%v", this.HostProcess) + `,`, `NamespaceOptions:` + strings.Replace(this.NamespaceOptions.String(), "WindowsNamespaceOption", "WindowsNamespaceOption", 1) + `,`, `}`, }, "") return s } func (this *WindowsPodSandboxConfig) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&WindowsPodSandboxConfig{`, `SecurityContext:` + strings.Replace(this.SecurityContext.String(), "WindowsSandboxSecurityContext", "WindowsSandboxSecurityContext", 1) + `,`, `}`, }, "") return s } func (this *WindowsContainerSecurityContext) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&WindowsContainerSecurityContext{`, `RunAsUsername:` + fmt.Sprintf("%v", this.RunAsUsername) + `,`, `CredentialSpec:` + fmt.Sprintf("%v", this.CredentialSpec) + `,`, `HostProcess:` + fmt.Sprintf("%v", this.HostProcess) + `,`, `}`, }, "") return s } func (this *WindowsContainerConfig) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&WindowsContainerConfig{`, `Resources:` + strings.Replace(this.Resources.String(), "WindowsContainerResources", "WindowsContainerResources", 1) + `,`, `SecurityContext:` + strings.Replace(this.SecurityContext.String(), "WindowsContainerSecurityContext", "WindowsContainerSecurityContext", 1) + `,`, `}`, }, "") return s } func (this *WindowsContainerResources) String() string { if this == nil { return "nil" } repeatedStringForAffinityCpus := "[]*WindowsCpuGroupAffinity{" for _, f := range this.AffinityCpus { repeatedStringForAffinityCpus += strings.Replace(f.String(), "WindowsCpuGroupAffinity", "WindowsCpuGroupAffinity", 1) + "," } repeatedStringForAffinityCpus += "}" s := strings.Join([]string{`&WindowsContainerResources{`, `CpuShares:` + fmt.Sprintf("%v", this.CpuShares) + `,`, `CpuCount:` + fmt.Sprintf("%v", this.CpuCount) + `,`, `CpuMaximum:` + fmt.Sprintf("%v", this.CpuMaximum) + `,`, `MemoryLimitInBytes:` + fmt.Sprintf("%v", this.MemoryLimitInBytes) + `,`, `RootfsSizeInBytes:` + fmt.Sprintf("%v", this.RootfsSizeInBytes) + `,`, `AffinityCpus:` + repeatedStringForAffinityCpus + `,`, `}`, }, "") return s } func (this *WindowsCpuGroupAffinity) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&WindowsCpuGroupAffinity{`, `CpuMask:` + fmt.Sprintf("%v", this.CpuMask) + `,`, `CpuGroup:` + fmt.Sprintf("%v", this.CpuGroup) + `,`, `}`, }, "") return s } func (this *ContainerMetadata) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ContainerMetadata{`, `Name:` + fmt.Sprintf("%v", this.Name) + `,`, `Attempt:` + fmt.Sprintf("%v", this.Attempt) + `,`, `}`, }, "") return s } func (this *Device) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&Device{`, `ContainerPath:` + fmt.Sprintf("%v", this.ContainerPath) + `,`, `HostPath:` + fmt.Sprintf("%v", this.HostPath) + `,`, `Permissions:` + fmt.Sprintf("%v", this.Permissions) + `,`, `}`, }, "") return s } func (this *CDIDevice) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&CDIDevice{`, `Name:` + fmt.Sprintf("%v", this.Name) + `,`, `}`, }, "") return s } func (this *ContainerConfig) String() string { if this == nil { return "nil" } repeatedStringForEnvs := "[]*KeyValue{" for _, f := range this.Envs { repeatedStringForEnvs += strings.Replace(f.String(), "KeyValue", "KeyValue", 1) + "," } repeatedStringForEnvs += "}" repeatedStringForMounts := "[]*Mount{" for _, f := range this.Mounts { repeatedStringForMounts += strings.Replace(f.String(), "Mount", "Mount", 1) + "," } repeatedStringForMounts += "}" repeatedStringForDevices := "[]*Device{" for _, f := range this.Devices { repeatedStringForDevices += strings.Replace(f.String(), "Device", "Device", 1) + "," } repeatedStringForDevices += "}" repeatedStringForCDIDevices := "[]*CDIDevice{" for _, f := range this.CDIDevices { repeatedStringForCDIDevices += strings.Replace(f.String(), "CDIDevice", "CDIDevice", 1) + "," } repeatedStringForCDIDevices += "}" keysForLabels := make([]string, 0, len(this.Labels)) for k := range this.Labels { keysForLabels = append(keysForLabels, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) mapStringForLabels := "map[string]string{" for _, k := range keysForLabels { mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) } mapStringForLabels += "}" keysForAnnotations := make([]string, 0, len(this.Annotations)) for k := range this.Annotations { keysForAnnotations = append(keysForAnnotations, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations) mapStringForAnnotations := "map[string]string{" for _, k := range keysForAnnotations { mapStringForAnnotations += fmt.Sprintf("%v: %v,", k, this.Annotations[k]) } mapStringForAnnotations += "}" s := strings.Join([]string{`&ContainerConfig{`, `Metadata:` + strings.Replace(this.Metadata.String(), "ContainerMetadata", "ContainerMetadata", 1) + `,`, `Image:` + strings.Replace(this.Image.String(), "ImageSpec", "ImageSpec", 1) + `,`, `Command:` + fmt.Sprintf("%v", this.Command) + `,`, `Args:` + fmt.Sprintf("%v", this.Args) + `,`, `WorkingDir:` + fmt.Sprintf("%v", this.WorkingDir) + `,`, `Envs:` + repeatedStringForEnvs + `,`, `Mounts:` + repeatedStringForMounts + `,`, `Devices:` + repeatedStringForDevices + `,`, `Labels:` + mapStringForLabels + `,`, `Annotations:` + mapStringForAnnotations + `,`, `LogPath:` + fmt.Sprintf("%v", this.LogPath) + `,`, `Stdin:` + fmt.Sprintf("%v", this.Stdin) + `,`, `StdinOnce:` + fmt.Sprintf("%v", this.StdinOnce) + `,`, `Tty:` + fmt.Sprintf("%v", this.Tty) + `,`, `Linux:` + strings.Replace(this.Linux.String(), "LinuxContainerConfig", "LinuxContainerConfig", 1) + `,`, `Windows:` + strings.Replace(this.Windows.String(), "WindowsContainerConfig", "WindowsContainerConfig", 1) + `,`, `CDIDevices:` + repeatedStringForCDIDevices + `,`, `}`, }, "") return s } func (this *CreateContainerRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&CreateContainerRequest{`, `PodSandboxId:` + fmt.Sprintf("%v", this.PodSandboxId) + `,`, `Config:` + strings.Replace(this.Config.String(), "ContainerConfig", "ContainerConfig", 1) + `,`, `SandboxConfig:` + strings.Replace(this.SandboxConfig.String(), "PodSandboxConfig", "PodSandboxConfig", 1) + `,`, `}`, }, "") return s } func (this *CreateContainerResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&CreateContainerResponse{`, `ContainerId:` + fmt.Sprintf("%v", this.ContainerId) + `,`, `}`, }, "") return s } func (this *StartContainerRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&StartContainerRequest{`, `ContainerId:` + fmt.Sprintf("%v", this.ContainerId) + `,`, `}`, }, "") return s } func (this *StartContainerResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&StartContainerResponse{`, `}`, }, "") return s } func (this *StopContainerRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&StopContainerRequest{`, `ContainerId:` + fmt.Sprintf("%v", this.ContainerId) + `,`, `Timeout:` + fmt.Sprintf("%v", this.Timeout) + `,`, `}`, }, "") return s } func (this *StopContainerResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&StopContainerResponse{`, `}`, }, "") return s } func (this *RemoveContainerRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&RemoveContainerRequest{`, `ContainerId:` + fmt.Sprintf("%v", this.ContainerId) + `,`, `}`, }, "") return s } func (this *RemoveContainerResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&RemoveContainerResponse{`, `}`, }, "") return s } func (this *ContainerStateValue) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ContainerStateValue{`, `State:` + fmt.Sprintf("%v", this.State) + `,`, `}`, }, "") return s } func (this *ContainerFilter) String() string { if this == nil { return "nil" } keysForLabelSelector := make([]string, 0, len(this.LabelSelector)) for k := range this.LabelSelector { keysForLabelSelector = append(keysForLabelSelector, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForLabelSelector) mapStringForLabelSelector := "map[string]string{" for _, k := range keysForLabelSelector { mapStringForLabelSelector += fmt.Sprintf("%v: %v,", k, this.LabelSelector[k]) } mapStringForLabelSelector += "}" s := strings.Join([]string{`&ContainerFilter{`, `Id:` + fmt.Sprintf("%v", this.Id) + `,`, `State:` + strings.Replace(this.State.String(), "ContainerStateValue", "ContainerStateValue", 1) + `,`, `PodSandboxId:` + fmt.Sprintf("%v", this.PodSandboxId) + `,`, `LabelSelector:` + mapStringForLabelSelector + `,`, `}`, }, "") return s } func (this *ListContainersRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ListContainersRequest{`, `Filter:` + strings.Replace(this.Filter.String(), "ContainerFilter", "ContainerFilter", 1) + `,`, `}`, }, "") return s } func (this *Container) String() string { if this == nil { return "nil" } keysForLabels := make([]string, 0, len(this.Labels)) for k := range this.Labels { keysForLabels = append(keysForLabels, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) mapStringForLabels := "map[string]string{" for _, k := range keysForLabels { mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) } mapStringForLabels += "}" keysForAnnotations := make([]string, 0, len(this.Annotations)) for k := range this.Annotations { keysForAnnotations = append(keysForAnnotations, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations) mapStringForAnnotations := "map[string]string{" for _, k := range keysForAnnotations { mapStringForAnnotations += fmt.Sprintf("%v: %v,", k, this.Annotations[k]) } mapStringForAnnotations += "}" s := strings.Join([]string{`&Container{`, `Id:` + fmt.Sprintf("%v", this.Id) + `,`, `PodSandboxId:` + fmt.Sprintf("%v", this.PodSandboxId) + `,`, `Metadata:` + strings.Replace(this.Metadata.String(), "ContainerMetadata", "ContainerMetadata", 1) + `,`, `Image:` + strings.Replace(this.Image.String(), "ImageSpec", "ImageSpec", 1) + `,`, `ImageRef:` + fmt.Sprintf("%v", this.ImageRef) + `,`, `State:` + fmt.Sprintf("%v", this.State) + `,`, `CreatedAt:` + fmt.Sprintf("%v", this.CreatedAt) + `,`, `Labels:` + mapStringForLabels + `,`, `Annotations:` + mapStringForAnnotations + `,`, `ImageId:` + fmt.Sprintf("%v", this.ImageId) + `,`, `}`, }, "") return s } func (this *ListContainersResponse) String() string { if this == nil { return "nil" } repeatedStringForContainers := "[]*Container{" for _, f := range this.Containers { repeatedStringForContainers += strings.Replace(f.String(), "Container", "Container", 1) + "," } repeatedStringForContainers += "}" s := strings.Join([]string{`&ListContainersResponse{`, `Containers:` + repeatedStringForContainers + `,`, `}`, }, "") return s } func (this *ContainerStatusRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ContainerStatusRequest{`, `ContainerId:` + fmt.Sprintf("%v", this.ContainerId) + `,`, `Verbose:` + fmt.Sprintf("%v", this.Verbose) + `,`, `}`, }, "") return s } func (this *ContainerStatus) String() string { if this == nil { return "nil" } repeatedStringForMounts := "[]*Mount{" for _, f := range this.Mounts { repeatedStringForMounts += strings.Replace(f.String(), "Mount", "Mount", 1) + "," } repeatedStringForMounts += "}" keysForLabels := make([]string, 0, len(this.Labels)) for k := range this.Labels { keysForLabels = append(keysForLabels, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) mapStringForLabels := "map[string]string{" for _, k := range keysForLabels { mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) } mapStringForLabels += "}" keysForAnnotations := make([]string, 0, len(this.Annotations)) for k := range this.Annotations { keysForAnnotations = append(keysForAnnotations, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations) mapStringForAnnotations := "map[string]string{" for _, k := range keysForAnnotations { mapStringForAnnotations += fmt.Sprintf("%v: %v,", k, this.Annotations[k]) } mapStringForAnnotations += "}" s := strings.Join([]string{`&ContainerStatus{`, `Id:` + fmt.Sprintf("%v", this.Id) + `,`, `Metadata:` + strings.Replace(this.Metadata.String(), "ContainerMetadata", "ContainerMetadata", 1) + `,`, `State:` + fmt.Sprintf("%v", this.State) + `,`, `CreatedAt:` + fmt.Sprintf("%v", this.CreatedAt) + `,`, `StartedAt:` + fmt.Sprintf("%v", this.StartedAt) + `,`, `FinishedAt:` + fmt.Sprintf("%v", this.FinishedAt) + `,`, `ExitCode:` + fmt.Sprintf("%v", this.ExitCode) + `,`, `Image:` + strings.Replace(this.Image.String(), "ImageSpec", "ImageSpec", 1) + `,`, `ImageRef:` + fmt.Sprintf("%v", this.ImageRef) + `,`, `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`, `Message:` + fmt.Sprintf("%v", this.Message) + `,`, `Labels:` + mapStringForLabels + `,`, `Annotations:` + mapStringForAnnotations + `,`, `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 } func (this *ContainerStatusResponse) String() string { if this == nil { return "nil" } keysForInfo := make([]string, 0, len(this.Info)) for k := range this.Info { keysForInfo = append(keysForInfo, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForInfo) mapStringForInfo := "map[string]string{" for _, k := range keysForInfo { mapStringForInfo += fmt.Sprintf("%v: %v,", k, this.Info[k]) } mapStringForInfo += "}" s := strings.Join([]string{`&ContainerStatusResponse{`, `Status:` + strings.Replace(this.Status.String(), "ContainerStatus", "ContainerStatus", 1) + `,`, `Info:` + mapStringForInfo + `,`, `}`, }, "") return s } func (this *ContainerResources) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ContainerResources{`, `Linux:` + strings.Replace(this.Linux.String(), "LinuxContainerResources", "LinuxContainerResources", 1) + `,`, `Windows:` + strings.Replace(this.Windows.String(), "WindowsContainerResources", "WindowsContainerResources", 1) + `,`, `}`, }, "") 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" } keysForAnnotations := make([]string, 0, len(this.Annotations)) for k := range this.Annotations { keysForAnnotations = append(keysForAnnotations, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations) mapStringForAnnotations := "map[string]string{" for _, k := range keysForAnnotations { mapStringForAnnotations += fmt.Sprintf("%v: %v,", k, this.Annotations[k]) } mapStringForAnnotations += "}" s := strings.Join([]string{`&UpdateContainerResourcesRequest{`, `ContainerId:` + fmt.Sprintf("%v", this.ContainerId) + `,`, `Linux:` + strings.Replace(this.Linux.String(), "LinuxContainerResources", "LinuxContainerResources", 1) + `,`, `Windows:` + strings.Replace(this.Windows.String(), "WindowsContainerResources", "WindowsContainerResources", 1) + `,`, `Annotations:` + mapStringForAnnotations + `,`, `}`, }, "") return s } func (this *UpdateContainerResourcesResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&UpdateContainerResourcesResponse{`, `}`, }, "") return s } func (this *ExecSyncRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ExecSyncRequest{`, `ContainerId:` + fmt.Sprintf("%v", this.ContainerId) + `,`, `Cmd:` + fmt.Sprintf("%v", this.Cmd) + `,`, `Timeout:` + fmt.Sprintf("%v", this.Timeout) + `,`, `}`, }, "") return s } func (this *ExecSyncResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ExecSyncResponse{`, `Stdout:` + fmt.Sprintf("%v", this.Stdout) + `,`, `Stderr:` + fmt.Sprintf("%v", this.Stderr) + `,`, `ExitCode:` + fmt.Sprintf("%v", this.ExitCode) + `,`, `}`, }, "") return s } func (this *ExecRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ExecRequest{`, `ContainerId:` + fmt.Sprintf("%v", this.ContainerId) + `,`, `Cmd:` + fmt.Sprintf("%v", this.Cmd) + `,`, `Tty:` + fmt.Sprintf("%v", this.Tty) + `,`, `Stdin:` + fmt.Sprintf("%v", this.Stdin) + `,`, `Stdout:` + fmt.Sprintf("%v", this.Stdout) + `,`, `Stderr:` + fmt.Sprintf("%v", this.Stderr) + `,`, `}`, }, "") return s } func (this *ExecResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ExecResponse{`, `Url:` + fmt.Sprintf("%v", this.Url) + `,`, `}`, }, "") return s } func (this *AttachRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&AttachRequest{`, `ContainerId:` + fmt.Sprintf("%v", this.ContainerId) + `,`, `Stdin:` + fmt.Sprintf("%v", this.Stdin) + `,`, `Tty:` + fmt.Sprintf("%v", this.Tty) + `,`, `Stdout:` + fmt.Sprintf("%v", this.Stdout) + `,`, `Stderr:` + fmt.Sprintf("%v", this.Stderr) + `,`, `}`, }, "") return s } func (this *AttachResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&AttachResponse{`, `Url:` + fmt.Sprintf("%v", this.Url) + `,`, `}`, }, "") return s } func (this *PortForwardRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&PortForwardRequest{`, `PodSandboxId:` + fmt.Sprintf("%v", this.PodSandboxId) + `,`, `Port:` + fmt.Sprintf("%v", this.Port) + `,`, `}`, }, "") return s } func (this *PortForwardResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&PortForwardResponse{`, `Url:` + fmt.Sprintf("%v", this.Url) + `,`, `}`, }, "") return s } func (this *ImageFilter) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ImageFilter{`, `Image:` + strings.Replace(this.Image.String(), "ImageSpec", "ImageSpec", 1) + `,`, `}`, }, "") return s } func (this *ListImagesRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ListImagesRequest{`, `Filter:` + strings.Replace(this.Filter.String(), "ImageFilter", "ImageFilter", 1) + `,`, `}`, }, "") return s } func (this *Image) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&Image{`, `Id:` + fmt.Sprintf("%v", this.Id) + `,`, `RepoTags:` + fmt.Sprintf("%v", this.RepoTags) + `,`, `RepoDigests:` + fmt.Sprintf("%v", this.RepoDigests) + `,`, `Size_:` + fmt.Sprintf("%v", this.Size_) + `,`, `Uid:` + strings.Replace(this.Uid.String(), "Int64Value", "Int64Value", 1) + `,`, `Username:` + fmt.Sprintf("%v", this.Username) + `,`, `Spec:` + strings.Replace(this.Spec.String(), "ImageSpec", "ImageSpec", 1) + `,`, `Pinned:` + fmt.Sprintf("%v", this.Pinned) + `,`, `}`, }, "") return s } func (this *ListImagesResponse) String() string { if this == nil { return "nil" } repeatedStringForImages := "[]*Image{" for _, f := range this.Images { repeatedStringForImages += strings.Replace(f.String(), "Image", "Image", 1) + "," } repeatedStringForImages += "}" s := strings.Join([]string{`&ListImagesResponse{`, `Images:` + repeatedStringForImages + `,`, `}`, }, "") return s } func (this *ImageStatusRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ImageStatusRequest{`, `Image:` + strings.Replace(this.Image.String(), "ImageSpec", "ImageSpec", 1) + `,`, `Verbose:` + fmt.Sprintf("%v", this.Verbose) + `,`, `}`, }, "") return s } func (this *ImageStatusResponse) String() string { if this == nil { return "nil" } keysForInfo := make([]string, 0, len(this.Info)) for k := range this.Info { keysForInfo = append(keysForInfo, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForInfo) mapStringForInfo := "map[string]string{" for _, k := range keysForInfo { mapStringForInfo += fmt.Sprintf("%v: %v,", k, this.Info[k]) } mapStringForInfo += "}" s := strings.Join([]string{`&ImageStatusResponse{`, `Image:` + strings.Replace(this.Image.String(), "Image", "Image", 1) + `,`, `Info:` + mapStringForInfo + `,`, `}`, }, "") return s } func (this *AuthConfig) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&AuthConfig{`, `Username:` + fmt.Sprintf("%v", this.Username) + `,`, `Password:` + fmt.Sprintf("%v", this.Password) + `,`, `Auth:` + fmt.Sprintf("%v", this.Auth) + `,`, `ServerAddress:` + fmt.Sprintf("%v", this.ServerAddress) + `,`, `IdentityToken:` + fmt.Sprintf("%v", this.IdentityToken) + `,`, `RegistryToken:` + fmt.Sprintf("%v", this.RegistryToken) + `,`, `}`, }, "") return s } func (this *PullImageRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&PullImageRequest{`, `Image:` + strings.Replace(this.Image.String(), "ImageSpec", "ImageSpec", 1) + `,`, `Auth:` + strings.Replace(this.Auth.String(), "AuthConfig", "AuthConfig", 1) + `,`, `SandboxConfig:` + strings.Replace(this.SandboxConfig.String(), "PodSandboxConfig", "PodSandboxConfig", 1) + `,`, `}`, }, "") return s } func (this *PullImageResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&PullImageResponse{`, `ImageRef:` + fmt.Sprintf("%v", this.ImageRef) + `,`, `}`, }, "") return s } func (this *RemoveImageRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&RemoveImageRequest{`, `Image:` + strings.Replace(this.Image.String(), "ImageSpec", "ImageSpec", 1) + `,`, `}`, }, "") return s } func (this *RemoveImageResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&RemoveImageResponse{`, `}`, }, "") return s } func (this *NetworkConfig) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&NetworkConfig{`, `PodCidr:` + fmt.Sprintf("%v", this.PodCidr) + `,`, `}`, }, "") return s } func (this *RuntimeConfig) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&RuntimeConfig{`, `NetworkConfig:` + strings.Replace(this.NetworkConfig.String(), "NetworkConfig", "NetworkConfig", 1) + `,`, `}`, }, "") return s } func (this *UpdateRuntimeConfigRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&UpdateRuntimeConfigRequest{`, `RuntimeConfig:` + strings.Replace(this.RuntimeConfig.String(), "RuntimeConfig", "RuntimeConfig", 1) + `,`, `}`, }, "") return s } func (this *UpdateRuntimeConfigResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&UpdateRuntimeConfigResponse{`, `}`, }, "") return s } func (this *RuntimeCondition) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&RuntimeCondition{`, `Type:` + fmt.Sprintf("%v", this.Type) + `,`, `Status:` + fmt.Sprintf("%v", this.Status) + `,`, `Reason:` + fmt.Sprintf("%v", this.Reason) + `,`, `Message:` + fmt.Sprintf("%v", this.Message) + `,`, `}`, }, "") return s } func (this *RuntimeStatus) String() string { if this == nil { return "nil" } repeatedStringForConditions := "[]*RuntimeCondition{" for _, f := range this.Conditions { repeatedStringForConditions += strings.Replace(f.String(), "RuntimeCondition", "RuntimeCondition", 1) + "," } repeatedStringForConditions += "}" s := strings.Join([]string{`&RuntimeStatus{`, `Conditions:` + repeatedStringForConditions + `,`, `}`, }, "") return s } func (this *StatusRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&StatusRequest{`, `Verbose:` + fmt.Sprintf("%v", this.Verbose) + `,`, `}`, }, "") 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) } github_com_gogo_protobuf_sortkeys.Strings(keysForInfo) mapStringForInfo := "map[string]string{" for _, k := range keysForInfo { mapStringForInfo += fmt.Sprintf("%v: %v,", k, this.Info[k]) } mapStringForInfo += "}" 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 } func (this *ImageFsInfoRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ImageFsInfoRequest{`, `}`, }, "") return s } func (this *UInt64Value) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&UInt64Value{`, `Value:` + fmt.Sprintf("%v", this.Value) + `,`, `}`, }, "") return s } func (this *FilesystemIdentifier) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&FilesystemIdentifier{`, `Mountpoint:` + fmt.Sprintf("%v", this.Mountpoint) + `,`, `}`, }, "") return s } func (this *FilesystemUsage) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&FilesystemUsage{`, `Timestamp:` + fmt.Sprintf("%v", this.Timestamp) + `,`, `FsId:` + strings.Replace(this.FsId.String(), "FilesystemIdentifier", "FilesystemIdentifier", 1) + `,`, `UsedBytes:` + strings.Replace(this.UsedBytes.String(), "UInt64Value", "UInt64Value", 1) + `,`, `InodesUsed:` + strings.Replace(this.InodesUsed.String(), "UInt64Value", "UInt64Value", 1) + `,`, `}`, }, "") return s } func (this *WindowsFilesystemUsage) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&WindowsFilesystemUsage{`, `Timestamp:` + fmt.Sprintf("%v", this.Timestamp) + `,`, `FsId:` + strings.Replace(this.FsId.String(), "FilesystemIdentifier", "FilesystemIdentifier", 1) + `,`, `UsedBytes:` + strings.Replace(this.UsedBytes.String(), "UInt64Value", "UInt64Value", 1) + `,`, `}`, }, "") return s } func (this *ImageFsInfoResponse) String() string { if this == nil { return "nil" } repeatedStringForImageFilesystems := "[]*FilesystemUsage{" for _, f := range this.ImageFilesystems { 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 } func (this *ContainerStatsRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ContainerStatsRequest{`, `ContainerId:` + fmt.Sprintf("%v", this.ContainerId) + `,`, `}`, }, "") return s } func (this *ContainerStatsResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ContainerStatsResponse{`, `Stats:` + strings.Replace(this.Stats.String(), "ContainerStats", "ContainerStats", 1) + `,`, `}`, }, "") return s } func (this *ListContainerStatsRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ListContainerStatsRequest{`, `Filter:` + strings.Replace(this.Filter.String(), "ContainerStatsFilter", "ContainerStatsFilter", 1) + `,`, `}`, }, "") return s } func (this *ContainerStatsFilter) String() string { if this == nil { return "nil" } keysForLabelSelector := make([]string, 0, len(this.LabelSelector)) for k := range this.LabelSelector { keysForLabelSelector = append(keysForLabelSelector, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForLabelSelector) mapStringForLabelSelector := "map[string]string{" for _, k := range keysForLabelSelector { mapStringForLabelSelector += fmt.Sprintf("%v: %v,", k, this.LabelSelector[k]) } mapStringForLabelSelector += "}" s := strings.Join([]string{`&ContainerStatsFilter{`, `Id:` + fmt.Sprintf("%v", this.Id) + `,`, `PodSandboxId:` + fmt.Sprintf("%v", this.PodSandboxId) + `,`, `LabelSelector:` + mapStringForLabelSelector + `,`, `}`, }, "") return s } func (this *ListContainerStatsResponse) String() string { if this == nil { return "nil" } repeatedStringForStats := "[]*ContainerStats{" for _, f := range this.Stats { repeatedStringForStats += strings.Replace(f.String(), "ContainerStats", "ContainerStats", 1) + "," } repeatedStringForStats += "}" s := strings.Join([]string{`&ListContainerStatsResponse{`, `Stats:` + repeatedStringForStats + `,`, `}`, }, "") return s } func (this *ContainerAttributes) String() string { if this == nil { return "nil" } keysForLabels := make([]string, 0, len(this.Labels)) for k := range this.Labels { keysForLabels = append(keysForLabels, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForLabels) mapStringForLabels := "map[string]string{" for _, k := range keysForLabels { mapStringForLabels += fmt.Sprintf("%v: %v,", k, this.Labels[k]) } mapStringForLabels += "}" keysForAnnotations := make([]string, 0, len(this.Annotations)) for k := range this.Annotations { keysForAnnotations = append(keysForAnnotations, k) } github_com_gogo_protobuf_sortkeys.Strings(keysForAnnotations) mapStringForAnnotations := "map[string]string{" for _, k := range keysForAnnotations { mapStringForAnnotations += fmt.Sprintf("%v: %v,", k, this.Annotations[k]) } mapStringForAnnotations += "}" s := strings.Join([]string{`&ContainerAttributes{`, `Id:` + fmt.Sprintf("%v", this.Id) + `,`, `Metadata:` + strings.Replace(this.Metadata.String(), "ContainerMetadata", "ContainerMetadata", 1) + `,`, `Labels:` + mapStringForLabels + `,`, `Annotations:` + mapStringForAnnotations + `,`, `}`, }, "") return s } func (this *ContainerStats) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ContainerStats{`, `Attributes:` + strings.Replace(this.Attributes.String(), "ContainerAttributes", "ContainerAttributes", 1) + `,`, `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 } func (this *WindowsContainerStats) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&WindowsContainerStats{`, `Attributes:` + strings.Replace(this.Attributes.String(), "ContainerAttributes", "ContainerAttributes", 1) + `,`, `Cpu:` + strings.Replace(this.Cpu.String(), "WindowsCpuUsage", "WindowsCpuUsage", 1) + `,`, `Memory:` + strings.Replace(this.Memory.String(), "WindowsMemoryUsage", "WindowsMemoryUsage", 1) + `,`, `WritableLayer:` + strings.Replace(this.WritableLayer.String(), "WindowsFilesystemUsage", "WindowsFilesystemUsage", 1) + `,`, `}`, }, "") return s } func (this *CpuUsage) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&CpuUsage{`, `Timestamp:` + fmt.Sprintf("%v", this.Timestamp) + `,`, `UsageCoreNanoSeconds:` + strings.Replace(this.UsageCoreNanoSeconds.String(), "UInt64Value", "UInt64Value", 1) + `,`, `UsageNanoCores:` + strings.Replace(this.UsageNanoCores.String(), "UInt64Value", "UInt64Value", 1) + `,`, `}`, }, "") return s } func (this *WindowsCpuUsage) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&WindowsCpuUsage{`, `Timestamp:` + fmt.Sprintf("%v", this.Timestamp) + `,`, `UsageCoreNanoSeconds:` + strings.Replace(this.UsageCoreNanoSeconds.String(), "UInt64Value", "UInt64Value", 1) + `,`, `UsageNanoCores:` + strings.Replace(this.UsageNanoCores.String(), "UInt64Value", "UInt64Value", 1) + `,`, `}`, }, "") return s } func (this *MemoryUsage) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&MemoryUsage{`, `Timestamp:` + fmt.Sprintf("%v", this.Timestamp) + `,`, `WorkingSetBytes:` + strings.Replace(this.WorkingSetBytes.String(), "UInt64Value", "UInt64Value", 1) + `,`, `AvailableBytes:` + strings.Replace(this.AvailableBytes.String(), "UInt64Value", "UInt64Value", 1) + `,`, `UsageBytes:` + strings.Replace(this.UsageBytes.String(), "UInt64Value", "UInt64Value", 1) + `,`, `RssBytes:` + strings.Replace(this.RssBytes.String(), "UInt64Value", "UInt64Value", 1) + `,`, `PageFaults:` + strings.Replace(this.PageFaults.String(), "UInt64Value", "UInt64Value", 1) + `,`, `MajorPageFaults:` + strings.Replace(this.MajorPageFaults.String(), "UInt64Value", "UInt64Value", 1) + `,`, `}`, }, "") 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" } s := strings.Join([]string{`&WindowsMemoryUsage{`, `Timestamp:` + fmt.Sprintf("%v", this.Timestamp) + `,`, `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 } func (this *ReopenContainerLogRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ReopenContainerLogRequest{`, `ContainerId:` + fmt.Sprintf("%v", this.ContainerId) + `,`, `}`, }, "") return s } func (this *ReopenContainerLogResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ReopenContainerLogResponse{`, `}`, }, "") return s } func (this *CheckpointContainerRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&CheckpointContainerRequest{`, `ContainerId:` + fmt.Sprintf("%v", this.ContainerId) + `,`, `Location:` + fmt.Sprintf("%v", this.Location) + `,`, `Timeout:` + fmt.Sprintf("%v", this.Timeout) + `,`, `}`, }, "") return s } func (this *CheckpointContainerResponse) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&CheckpointContainerResponse{`, `}`, }, "") return s } func (this *GetEventsRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&GetEventsRequest{`, `}`, }, "") return s } func (this *ContainerEventResponse) String() string { if this == nil { return "nil" } repeatedStringForContainersStatuses := "[]*ContainerStatus{" for _, f := range this.ContainersStatuses { repeatedStringForContainersStatuses += strings.Replace(f.String(), "ContainerStatus", "ContainerStatus", 1) + "," } repeatedStringForContainersStatuses += "}" s := strings.Join([]string{`&ContainerEventResponse{`, `ContainerId:` + fmt.Sprintf("%v", this.ContainerId) + `,`, `ContainerEventType:` + fmt.Sprintf("%v", this.ContainerEventType) + `,`, `CreatedAt:` + fmt.Sprintf("%v", this.CreatedAt) + `,`, `PodSandboxStatus:` + strings.Replace(this.PodSandboxStatus.String(), "PodSandboxStatus", "PodSandboxStatus", 1) + `,`, `ContainersStatuses:` + repeatedStringForContainersStatuses + `,`, `}`, }, "") return s } func (this *ListMetricDescriptorsRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ListMetricDescriptorsRequest{`, `}`, }, "") return s } func (this *ListMetricDescriptorsResponse) String() string { if this == nil { return "nil" } repeatedStringForDescriptors := "[]*MetricDescriptor{" for _, f := range this.Descriptors { repeatedStringForDescriptors += strings.Replace(f.String(), "MetricDescriptor", "MetricDescriptor", 1) + "," } repeatedStringForDescriptors += "}" s := strings.Join([]string{`&ListMetricDescriptorsResponse{`, `Descriptors:` + repeatedStringForDescriptors + `,`, `}`, }, "") return s } func (this *MetricDescriptor) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&MetricDescriptor{`, `Name:` + fmt.Sprintf("%v", this.Name) + `,`, `Help:` + fmt.Sprintf("%v", this.Help) + `,`, `LabelKeys:` + fmt.Sprintf("%v", this.LabelKeys) + `,`, `}`, }, "") return s } func (this *ListPodSandboxMetricsRequest) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&ListPodSandboxMetricsRequest{`, `}`, }, "") return s } func (this *ListPodSandboxMetricsResponse) String() string { if this == nil { return "nil" } repeatedStringForPodMetrics := "[]*PodSandboxMetrics{" for _, f := range this.PodMetrics { repeatedStringForPodMetrics += strings.Replace(f.String(), "PodSandboxMetrics", "PodSandboxMetrics", 1) + "," } repeatedStringForPodMetrics += "}" s := strings.Join([]string{`&ListPodSandboxMetricsResponse{`, `PodMetrics:` + repeatedStringForPodMetrics + `,`, `}`, }, "") return s } func (this *PodSandboxMetrics) String() string { if this == nil { return "nil" } repeatedStringForMetrics := "[]*Metric{" for _, f := range this.Metrics { repeatedStringForMetrics += strings.Replace(f.String(), "Metric", "Metric", 1) + "," } repeatedStringForMetrics += "}" repeatedStringForContainerMetrics := "[]*ContainerMetrics{" for _, f := range this.ContainerMetrics { repeatedStringForContainerMetrics += strings.Replace(f.String(), "ContainerMetrics", "ContainerMetrics", 1) + "," } repeatedStringForContainerMetrics += "}" s := strings.Join([]string{`&PodSandboxMetrics{`, `PodSandboxId:` + fmt.Sprintf("%v", this.PodSandboxId) + `,`, `Metrics:` + repeatedStringForMetrics + `,`, `ContainerMetrics:` + repeatedStringForContainerMetrics + `,`, `}`, }, "") return s } func (this *ContainerMetrics) String() string { if this == nil { return "nil" } repeatedStringForMetrics := "[]*Metric{" for _, f := range this.Metrics { repeatedStringForMetrics += strings.Replace(f.String(), "Metric", "Metric", 1) + "," } repeatedStringForMetrics += "}" s := strings.Join([]string{`&ContainerMetrics{`, `ContainerId:` + fmt.Sprintf("%v", this.ContainerId) + `,`, `Metrics:` + repeatedStringForMetrics + `,`, `}`, }, "") return s } func (this *Metric) String() string { if this == nil { return "nil" } s := strings.Join([]string{`&Metric{`, `Name:` + fmt.Sprintf("%v", this.Name) + `,`, `Timestamp:` + fmt.Sprintf("%v", this.Timestamp) + `,`, `MetricType:` + fmt.Sprintf("%v", this.MetricType) + `,`, `LabelValues:` + fmt.Sprintf("%v", this.LabelValues) + `,`, `Value:` + strings.Replace(this.Value.String(), "UInt64Value", "UInt64Value", 1) + `,`, `}`, }, "") 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() { return "nil" } pv := reflect.Indirect(rv).Interface() return fmt.Sprintf("*%v", pv) } func (m *VersionRequest) 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: VersionRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: VersionRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Version", 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.Version = 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 *VersionResponse) 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: VersionResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: VersionResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Version", 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.Version = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RuntimeName", 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.RuntimeName = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RuntimeVersion", 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.RuntimeVersion = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RuntimeApiVersion", 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.RuntimeApiVersion = 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 *DNSConfig) 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: DNSConfig: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: DNSConfig: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Servers", 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.Servers = append(m.Servers, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Searches", 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.Searches = append(m.Searches, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Options", 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.Options = append(m.Options, 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 *PortMapping) 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: PortMapping: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PortMapping: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Protocol", wireType) } m.Protocol = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Protocol |= Protocol(b&0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerPort", wireType) } m.ContainerPort = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ContainerPort |= int32(b&0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field HostPort", wireType) } m.HostPort = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.HostPort |= int32(b&0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field HostIp", 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.HostIp = 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 *Mount) 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: Mount: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Mount: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerPath", 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.ContainerPath = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field HostPath", 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.HostPath = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Readonly", 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.Readonly = bool(v != 0) case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field SelinuxRelabel", 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.SelinuxRelabel = bool(v != 0) case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Propagation", wireType) } m.Propagation = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Propagation |= MountPropagation(b&0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field UidMappings", 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.UidMappings = append(m.UidMappings, &IDMapping{}) if err := m.UidMappings[len(m.UidMappings)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field GidMappings", 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.GidMappings = append(m.GidMappings, &IDMapping{}) if err := m.GidMappings[len(m.GidMappings)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 8: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RecursiveReadOnly", 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.RecursiveReadOnly = bool(v != 0) case 9: 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 *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: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field HostId", wireType) } m.HostId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.HostId |= uint32(b&0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", wireType) } m.ContainerId = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ContainerId |= uint32(b&0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Length", wireType) } 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 } } 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:]) 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 *NamespaceOption) 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: NamespaceOption: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: NamespaceOption: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Network", wireType) } m.Network = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Network |= NamespaceMode(b&0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Pid", wireType) } m.Pid = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Pid |= NamespaceMode(b&0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Ipc", wireType) } m.Ipc = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Ipc |= NamespaceMode(b&0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field TargetId", 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.TargetId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field UsernsOptions", 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.UsernsOptions == nil { m.UsernsOptions = &UserNamespace{} } if err := m.UsernsOptions.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 *Int64Value) 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: Int64Value: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Int64Value: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) } m.Value = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Value |= int64(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 (m *LinuxSandboxSecurityContext) 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: LinuxSandboxSecurityContext: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: LinuxSandboxSecurityContext: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field NamespaceOptions", 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.NamespaceOptions == nil { m.NamespaceOptions = &NamespaceOption{} } if err := m.NamespaceOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field SelinuxOptions", 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.SelinuxOptions == nil { m.SelinuxOptions = &SELinuxOption{} } if err := m.SelinuxOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RunAsUser", 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.RunAsUser == nil { m.RunAsUser = &Int64Value{} } if err := m.RunAsUser.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ReadonlyRootfs", 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.ReadonlyRootfs = bool(v != 0) case 5: 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) } case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Privileged", 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.Privileged = bool(v != 0) case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field SeccompProfilePath", 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.SeccompProfilePath = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RunAsGroup", 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.RunAsGroup == nil { m.RunAsGroup = &Int64Value{} } if err := m.RunAsGroup.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 9: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Seccomp", 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.Seccomp == nil { m.Seccomp = &SecurityProfile{} } if err := m.Seccomp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 10: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Apparmor", 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.Apparmor == nil { m.Apparmor = &SecurityProfile{} } if err := m.Apparmor.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 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:]) 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 *SecurityProfile) 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: SecurityProfile: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SecurityProfile: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ProfileType", wireType) } m.ProfileType = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ProfileType |= SecurityProfile_ProfileType(b&0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field LocalhostRef", 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.LocalhostRef = 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 *LinuxPodSandboxConfig) 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: LinuxPodSandboxConfig: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: LinuxPodSandboxConfig: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CgroupParent", 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.CgroupParent = string(dAtA[iNdEx:postIndex]) 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 = &LinuxSandboxSecurityContext{} } if err := m.SecurityContext.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Sysctls", 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.Sysctls == nil { m.Sysctls = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := 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) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthApi } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthApi } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthApi } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthApi } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipApi(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthApi } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Sysctls[mapkey] = mapvalue iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Overhead", 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.Overhead == nil { m.Overhead = &LinuxContainerResources{} } if err := m.Overhead.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: 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 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 *PodSandboxMetadata) 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: PodSandboxMetadata: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PodSandboxMetadata: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { 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 Uid", 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.Uid = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Namespace", 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.Namespace = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Attempt", wireType) } m.Attempt = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Attempt |= uint32(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 (m *PodSandboxConfig) 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: PodSandboxConfig: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PodSandboxConfig: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Metadata", 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.Metadata == nil { m.Metadata = &PodSandboxMetadata{} } if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Hostname", 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.Hostname = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field LogDirectory", 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.LogDirectory = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field DnsConfig", 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.DnsConfig == nil { m.DnsConfig = &DNSConfig{} } if err := m.DnsConfig.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PortMappings", 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.PortMappings = append(m.PortMappings, &PortMapping{}) if err := m.PortMappings[len(m.PortMappings)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Labels", 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.Labels == nil { m.Labels = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := 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) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthApi } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthApi } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthApi } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthApi } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipApi(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthApi } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Labels[mapkey] = mapvalue iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Annotations", 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.Annotations == nil { m.Annotations = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := 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) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthApi } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthApi } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthApi } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthApi } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipApi(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthApi } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Annotations[mapkey] = mapvalue iNdEx = postIndex case 8: 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 = &LinuxPodSandboxConfig{} } if err := m.Linux.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 9: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Windows", 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.Windows == nil { m.Windows = &WindowsPodSandboxConfig{} } if err := m.Windows.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 *RunPodSandboxRequest) 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: RunPodSandboxRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RunPodSandboxRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Config", 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.Config == nil { m.Config = &PodSandboxConfig{} } if err := m.Config.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RuntimeHandler", 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.RuntimeHandler = 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 *RunPodSandboxResponse) 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: RunPodSandboxResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RunPodSandboxResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PodSandboxId", 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.PodSandboxId = 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 *StopPodSandboxRequest) 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: StopPodSandboxRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StopPodSandboxRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PodSandboxId", 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.PodSandboxId = 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 *StopPodSandboxResponse) 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: StopPodSandboxResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StopPodSandboxResponse: 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 *RemovePodSandboxRequest) 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: RemovePodSandboxRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RemovePodSandboxRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PodSandboxId", 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.PodSandboxId = 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 *RemovePodSandboxResponse) 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: RemovePodSandboxResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RemovePodSandboxResponse: 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 *PodSandboxStatusRequest) 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: PodSandboxStatusRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PodSandboxStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PodSandboxId", 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.PodSandboxId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: 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:]) 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 *PodIP) 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: PodIP: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PodIP: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Ip", 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.Ip = 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 *PodSandboxNetworkStatus) 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: PodSandboxNetworkStatus: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PodSandboxNetworkStatus: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Ip", 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.Ip = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field AdditionalIps", 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.AdditionalIps = append(m.AdditionalIps, &PodIP{}) if err := m.AdditionalIps[len(m.AdditionalIps)-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 *Namespace) 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: Namespace: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Namespace: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Options", 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.Options == nil { m.Options = &NamespaceOption{} } if err := m.Options.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 *LinuxPodSandboxStatus) 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: LinuxPodSandboxStatus: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: LinuxPodSandboxStatus: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Namespaces", 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.Namespaces == nil { m.Namespaces = &Namespace{} } if err := m.Namespaces.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 *PodSandboxStatus) 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: PodSandboxStatus: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PodSandboxStatus: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Id", 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.Id = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Metadata", 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.Metadata == nil { m.Metadata = &PodSandboxMetadata{} } if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) } m.State = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.State |= PodSandboxState(b&0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType) } m.CreatedAt = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CreatedAt |= int64(b&0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Network", 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.Network == nil { m.Network = &PodSandboxNetworkStatus{} } if err := m.Network.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 6: 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 = &LinuxPodSandboxStatus{} } if err := m.Linux.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Labels", 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.Labels == nil { m.Labels = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := 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) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthApi } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthApi } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthApi } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthApi } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipApi(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthApi } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Labels[mapkey] = mapvalue iNdEx = postIndex case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Annotations", 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.Annotations == nil { m.Annotations = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := 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) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthApi } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthApi } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthApi } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthApi } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipApi(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthApi } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Annotations[mapkey] = mapvalue iNdEx = postIndex case 9: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RuntimeHandler", 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.RuntimeHandler = 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 *PodSandboxStatusResponse) 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: PodSandboxStatusResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PodSandboxStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Status", 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.Status == nil { m.Status = &PodSandboxStatus{} } if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Info", 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.Info == nil { m.Info = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := 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) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthApi } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthApi } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthApi } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthApi } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipApi(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthApi } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Info[mapkey] = mapvalue iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainersStatuses", 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.ContainersStatuses = append(m.ContainersStatuses, &ContainerStatus{}) if err := m.ContainersStatuses[len(m.ContainersStatuses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: 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 } } 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 *PodSandboxStateValue) 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: PodSandboxStateValue: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PodSandboxStateValue: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) } m.State = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.State |= PodSandboxState(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 (m *PodSandboxFilter) 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: PodSandboxFilter: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PodSandboxFilter: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Id", 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.Id = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field State", 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.State == nil { m.State = &PodSandboxStateValue{} } if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field LabelSelector", 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.LabelSelector == nil { m.LabelSelector = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := 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) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthApi } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthApi } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthApi } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthApi } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipApi(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthApi } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.LabelSelector[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 *ListPodSandboxRequest) 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: ListPodSandboxRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListPodSandboxRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Filter", 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.Filter == nil { m.Filter = &PodSandboxFilter{} } if err := m.Filter.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 *PodSandbox) 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: PodSandbox: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PodSandbox: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Id", 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.Id = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Metadata", 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.Metadata == nil { m.Metadata = &PodSandboxMetadata{} } if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) } m.State = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.State |= PodSandboxState(b&0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType) } m.CreatedAt = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CreatedAt |= int64(b&0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Labels", 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.Labels == nil { m.Labels = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := 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) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthApi } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthApi } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthApi } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthApi } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipApi(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthApi } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Labels[mapkey] = mapvalue iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Annotations", 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.Annotations == nil { m.Annotations = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := 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) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthApi } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthApi } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthApi } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthApi } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipApi(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthApi } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Annotations[mapkey] = mapvalue iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RuntimeHandler", 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.RuntimeHandler = 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 *ListPodSandboxResponse) 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: ListPodSandboxResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListPodSandboxResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Items", 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.Items = append(m.Items, &PodSandbox{}) if err := m.Items[len(m.Items)-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 *PodSandboxStatsRequest) 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: PodSandboxStatsRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PodSandboxStatsRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PodSandboxId", 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.PodSandboxId = 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 *PodSandboxStatsResponse) 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: PodSandboxStatsResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PodSandboxStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Stats", 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.Stats == nil { m.Stats = &PodSandboxStats{} } if err := m.Stats.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 *PodSandboxStatsFilter) 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: PodSandboxStatsFilter: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PodSandboxStatsFilter: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Id", 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.Id = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field LabelSelector", 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.LabelSelector == nil { m.LabelSelector = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := 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) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthApi } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthApi } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthApi } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthApi } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipApi(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthApi } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.LabelSelector[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 *ListPodSandboxStatsRequest) 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: ListPodSandboxStatsRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListPodSandboxStatsRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Filter", 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.Filter == nil { m.Filter = &PodSandboxStatsFilter{} } if err := m.Filter.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 *ListPodSandboxStatsResponse) 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: ListPodSandboxStatsResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListPodSandboxStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Stats", 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.Stats = append(m.Stats, &PodSandboxStats{}) if err := m.Stats[len(m.Stats)-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 *PodSandboxAttributes) 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: PodSandboxAttributes: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PodSandboxAttributes: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Id", 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.Id = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Metadata", 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.Metadata == nil { m.Metadata = &PodSandboxMetadata{} } if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Labels", 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.Labels == nil { m.Labels = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := 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) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthApi } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthApi } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthApi } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthApi } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipApi(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthApi } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Labels[mapkey] = mapvalue iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Annotations", 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.Annotations == nil { m.Annotations = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := 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) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthApi } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthApi } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthApi } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthApi } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipApi(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthApi } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } 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 *PodSandboxStats) 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: PodSandboxStats: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PodSandboxStats: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Attributes", 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.Attributes == nil { m.Attributes = &PodSandboxAttributes{} } if err := m.Attributes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: 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 = &LinuxPodSandboxStats{} } if err := m.Linux.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Windows", 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.Windows == nil { m.Windows = &WindowsPodSandboxStats{} } if err := m.Windows.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 *LinuxPodSandboxStats) 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: LinuxPodSandboxStats: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: LinuxPodSandboxStats: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cpu", 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.Cpu == nil { m.Cpu = &CpuUsage{} } if err := m.Cpu.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: 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.Memory.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Network", 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.Network == nil { m.Network = &NetworkUsage{} } if err := m.Network.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Process", 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.Process == nil { m.Process = &ProcessUsage{} } if err := m.Process.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Containers", 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.Containers = append(m.Containers, &ContainerStats{}) if err := m.Containers[len(m.Containers)-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 *WindowsPodSandboxStats) 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: WindowsPodSandboxStats: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WindowsPodSandboxStats: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cpu", 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.Cpu == nil { m.Cpu = &WindowsCpuUsage{} } if err := m.Cpu.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: 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 = &WindowsMemoryUsage{} } if err := m.Memory.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Network", 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.Network == nil { m.Network = &WindowsNetworkUsage{} } if err := m.Network.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Process", 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.Process == nil { m.Process = &WindowsProcessUsage{} } if err := m.Process.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Containers", 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.Containers = append(m.Containers, &WindowsContainerStats{}) if err := m.Containers[len(m.Containers)-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 *NetworkUsage) 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: NetworkUsage: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: NetworkUsage: 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 DefaultInterface", 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.DefaultInterface == nil { m.DefaultInterface = &NetworkInterfaceUsage{} } if err := m.DefaultInterface.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Interfaces", 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.Interfaces = append(m.Interfaces, &NetworkInterfaceUsage{}) if err := m.Interfaces[len(m.Interfaces)-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 *WindowsNetworkUsage) 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: WindowsNetworkUsage: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WindowsNetworkUsage: 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 DefaultInterface", 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.DefaultInterface == nil { m.DefaultInterface = &WindowsNetworkInterfaceUsage{} } if err := m.DefaultInterface.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Interfaces", 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.Interfaces = append(m.Interfaces, &WindowsNetworkInterfaceUsage{}) if err := m.Interfaces[len(m.Interfaces)-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 *NetworkInterfaceUsage) 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: NetworkInterfaceUsage: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: NetworkInterfaceUsage: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { 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 RxBytes", 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.RxBytes == nil { m.RxBytes = &UInt64Value{} } if err := m.RxBytes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RxErrors", 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.RxErrors == nil { m.RxErrors = &UInt64Value{} } if err := m.RxErrors.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field TxBytes", 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.TxBytes == nil { m.TxBytes = &UInt64Value{} } if err := m.TxBytes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field TxErrors", 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.TxErrors == nil { m.TxErrors = &UInt64Value{} } if err := m.TxErrors.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 *WindowsNetworkInterfaceUsage) 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: WindowsNetworkInterfaceUsage: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WindowsNetworkInterfaceUsage: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { 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 RxBytes", 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.RxBytes == nil { m.RxBytes = &UInt64Value{} } if err := m.RxBytes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RxPacketsDropped", 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.RxPacketsDropped == nil { m.RxPacketsDropped = &UInt64Value{} } if err := m.RxPacketsDropped.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field TxBytes", 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.TxBytes == nil { m.TxBytes = &UInt64Value{} } if err := m.TxBytes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field TxPacketsDropped", 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.TxPacketsDropped == nil { m.TxPacketsDropped = &UInt64Value{} } if err := m.TxPacketsDropped.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 *ProcessUsage) 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: ProcessUsage: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ProcessUsage: 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 ProcessCount", 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.ProcessCount == nil { m.ProcessCount = &UInt64Value{} } if err := m.ProcessCount.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 *WindowsProcessUsage) 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: WindowsProcessUsage: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WindowsProcessUsage: 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 ProcessCount", 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.ProcessCount == nil { m.ProcessCount = &UInt64Value{} } if err := m.ProcessCount.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 *ImageSpec) 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: ImageSpec: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ImageSpec: 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 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.Image = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Annotations", 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.Annotations == nil { m.Annotations = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := 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) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthApi } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthApi } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthApi } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthApi } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipApi(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthApi } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Annotations[mapkey] = mapvalue iNdEx = postIndex case 18: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field UserSpecifiedImage", 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.UserSpecifiedImage = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 19: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RuntimeHandler", 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.RuntimeHandler = 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 *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: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Key", 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.Key = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { 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 { 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.CpusetCpus = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CpusetMems", 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.CpusetMems = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field HugepageLimits", 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.HugepageLimits = append(m.HugepageLimits, &HugepageLimit{}) if err := m.HugepageLimits[len(m.HugepageLimits)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 9: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Unified", 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.Unified == nil { m.Unified = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := 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) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthApi } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthApi } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthApi } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthApi } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipApi(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthApi } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Unified[mapkey] = mapvalue iNdEx = postIndex case 10: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field MemorySwapLimitInBytes", wireType) } m.MemorySwapLimitInBytes = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.MemorySwapLimitInBytes |= int64(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 (m *HugepageLimit) 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: HugepageLimit: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: HugepageLimit: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PageSize", 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.PageSize = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType) } m.Limit = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Limit |= uint64(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 (m *SELinuxOption) 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: SELinuxOption: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: SELinuxOption: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field User", 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.User = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Role", 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.Role = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Type", 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.Type = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Level", 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.Level = 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 *Capability) 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: Capability: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Capability: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field AddCapabilities", 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.AddCapabilities = append(m.AddCapabilities, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field DropCapabilities", 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.DropCapabilities = append(m.DropCapabilities, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field AddAmbientCapabilities", 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.AddAmbientCapabilities = append(m.AddAmbientCapabilities, 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 *LinuxContainerSecurityContext) 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: LinuxContainerSecurityContext: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: LinuxContainerSecurityContext: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Capabilities", 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.Capabilities == nil { m.Capabilities = &Capability{} } if err := m.Capabilities.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Privileged", 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.Privileged = bool(v != 0) case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field NamespaceOptions", 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.NamespaceOptions == nil { m.NamespaceOptions = &NamespaceOption{} } if err := m.NamespaceOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field SelinuxOptions", 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.SelinuxOptions == nil { m.SelinuxOptions = &SELinuxOption{} } if err := m.SelinuxOptions.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RunAsUser", 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.RunAsUser == nil { m.RunAsUser = &Int64Value{} } if err := m.RunAsUser.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RunAsUsername", 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.RunAsUsername = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 7: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ReadonlyRootfs", 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.ReadonlyRootfs = bool(v != 0) case 8: 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) } case 9: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ApparmorProfile", 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.ApparmorProfile = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 10: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field SeccompProfilePath", 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.SeccompProfilePath = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 11: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field NoNewPrivs", 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.NoNewPrivs = bool(v != 0) case 12: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RunAsGroup", 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.RunAsGroup == nil { m.RunAsGroup = &Int64Value{} } if err := m.RunAsGroup.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 13: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field MaskedPaths", 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.MaskedPaths = append(m.MaskedPaths, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 14: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ReadonlyPaths", 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.ReadonlyPaths = append(m.ReadonlyPaths, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 15: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Seccomp", 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.Seccomp == nil { m.Seccomp = &SecurityProfile{} } if err := m.Seccomp.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 16: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Apparmor", 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.Apparmor == nil { m.Apparmor = &SecurityProfile{} } if err := m.Apparmor.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 17: 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:]) 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:]) 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 *WindowsNamespaceOption) 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: WindowsNamespaceOption: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WindowsNamespaceOption: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Network", wireType) } m.Network = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Network |= NamespaceMode(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 (m *WindowsSandboxSecurityContext) 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: WindowsSandboxSecurityContext: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WindowsSandboxSecurityContext: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RunAsUsername", 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.RunAsUsername = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CredentialSpec", 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.CredentialSpec = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field HostProcess", 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.HostProcess = bool(v != 0) case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field NamespaceOptions", 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.NamespaceOptions == nil { m.NamespaceOptions = &WindowsNamespaceOption{} } if err := m.NamespaceOptions.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 *WindowsPodSandboxConfig) 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: WindowsPodSandboxConfig: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WindowsPodSandboxConfig: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: 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 = &WindowsSandboxSecurityContext{} } 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 *WindowsContainerSecurityContext) 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: WindowsContainerSecurityContext: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WindowsContainerSecurityContext: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RunAsUsername", 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.RunAsUsername = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CredentialSpec", 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.CredentialSpec = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field HostProcess", 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.HostProcess = bool(v != 0) 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 *WindowsContainerConfig) 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: WindowsContainerConfig: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WindowsContainerConfig: 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 = &WindowsContainerResources{} } 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 = &WindowsContainerSecurityContext{} } 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 *WindowsContainerResources) 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: WindowsContainerResources: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WindowsContainerResources: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: 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 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CpuCount", wireType) } m.CpuCount = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CpuCount |= int64(b&0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CpuMaximum", wireType) } m.CpuMaximum = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CpuMaximum |= 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 RootfsSizeInBytes", wireType) } m.RootfsSizeInBytes = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.RootfsSizeInBytes |= int64(b&0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field AffinityCpus", 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.AffinityCpus = append(m.AffinityCpus, &WindowsCpuGroupAffinity{}) if err := m.AffinityCpus[len(m.AffinityCpus)-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 *WindowsCpuGroupAffinity) 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: WindowsCpuGroupAffinity: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WindowsCpuGroupAffinity: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CpuMask", wireType) } m.CpuMask = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CpuMask |= uint64(b&0x7F) << shift if b < 0x80 { break } } case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CpuGroup", wireType) } m.CpuGroup = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CpuGroup |= uint32(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 (m *ContainerMetadata) 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: ContainerMetadata: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ContainerMetadata: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { 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 != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Attempt", wireType) } m.Attempt = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Attempt |= uint32(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 (m *Device) 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: Device: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Device: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerPath", 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.ContainerPath = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field HostPath", 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.HostPath = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Permissions", 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.Permissions = 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 *CDIDevice) 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: CDIDevice: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CDIDevice: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { 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 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 *ContainerConfig) 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: ContainerConfig: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ContainerConfig: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Metadata", 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.Metadata == nil { m.Metadata = &ContainerMetadata{} } if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: 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 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Command", 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.Command = append(m.Command, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Args", 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.Args = append(m.Args, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field WorkingDir", 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.WorkingDir = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Envs", 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.Envs = append(m.Envs, &KeyValue{}) if err := m.Envs[len(m.Envs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Mounts", 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.Mounts = append(m.Mounts, &Mount{}) if err := m.Mounts[len(m.Mounts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Devices", 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.Devices = append(m.Devices, &Device{}) if err := m.Devices[len(m.Devices)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 9: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Labels", 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.Labels == nil { m.Labels = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := 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) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthApi } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthApi } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthApi } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthApi } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipApi(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthApi } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Labels[mapkey] = mapvalue iNdEx = postIndex case 10: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Annotations", 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.Annotations == nil { m.Annotations = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := 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) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthApi } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthApi } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthApi } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthApi } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipApi(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthApi } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Annotations[mapkey] = mapvalue iNdEx = postIndex case 11: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field LogPath", 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.LogPath = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 12: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Stdin", 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.Stdin = bool(v != 0) case 13: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StdinOnce", 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.StdinOnce = bool(v != 0) case 14: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Tty", 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.Tty = bool(v != 0) case 15: 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 = &LinuxContainerConfig{} } if err := m.Linux.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 16: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Windows", 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.Windows == nil { m.Windows = &WindowsContainerConfig{} } if err := m.Windows.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 17: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CDIDevices", 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.CDIDevices = append(m.CDIDevices, &CDIDevice{}) if err := m.CDIDevices[len(m.CDIDevices)-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 *CreateContainerRequest) 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: CreateContainerRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CreateContainerRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PodSandboxId", 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.PodSandboxId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Config", 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.Config == nil { m.Config = &ContainerConfig{} } if err := m.Config.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 *CreateContainerResponse) 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: CreateContainerResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CreateContainerResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", 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.ContainerId = 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 *StartContainerRequest) 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: StartContainerRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StartContainerRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", 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.ContainerId = 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 *StartContainerResponse) 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: StartContainerResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StartContainerResponse: 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 *StopContainerRequest) 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: StopContainerRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StopContainerRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", 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.ContainerId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Timeout", wireType) } m.Timeout = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Timeout |= int64(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 (m *StopContainerResponse) 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: StopContainerResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StopContainerResponse: 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 *RemoveContainerRequest) 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: RemoveContainerRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RemoveContainerRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", 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.ContainerId = 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 *RemoveContainerResponse) 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: RemoveContainerResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RemoveContainerResponse: 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 *ContainerStateValue) 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: ContainerStateValue: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ContainerStateValue: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) } m.State = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.State |= ContainerState(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 (m *ContainerFilter) 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: ContainerFilter: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ContainerFilter: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Id", 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.Id = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field State", 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.State == nil { m.State = &ContainerStateValue{} } if err := m.State.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PodSandboxId", 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.PodSandboxId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field LabelSelector", 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.LabelSelector == nil { m.LabelSelector = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := 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) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthApi } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthApi } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthApi } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthApi } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipApi(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthApi } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.LabelSelector[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 *ListContainersRequest) 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: ListContainersRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListContainersRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Filter", 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.Filter == nil { m.Filter = &ContainerFilter{} } if err := m.Filter.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 *Container) 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: Container: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Container: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Id", 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.Id = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PodSandboxId", 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.PodSandboxId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Metadata", 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.Metadata == nil { m.Metadata = &ContainerMetadata{} } if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: 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 5: 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 case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) } m.State = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.State |= ContainerState(b&0x7F) << shift if b < 0x80 { break } } case 7: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType) } m.CreatedAt = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CreatedAt |= int64(b&0x7F) << shift if b < 0x80 { break } } case 8: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Labels", 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.Labels == nil { m.Labels = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := 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) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthApi } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthApi } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthApi } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthApi } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipApi(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthApi } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Labels[mapkey] = mapvalue iNdEx = postIndex case 9: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Annotations", 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.Annotations == nil { m.Annotations = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := 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) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthApi } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthApi } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthApi } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthApi } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipApi(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthApi } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } 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:]) 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 *ListContainersResponse) 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: ListContainersResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListContainersResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Containers", 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.Containers = append(m.Containers, &Container{}) if err := m.Containers[len(m.Containers)-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 *ContainerStatusRequest) 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: ContainerStatusRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ContainerStatusRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", 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.ContainerId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: 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:]) 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 *ContainerStatus) 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: ContainerStatus: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ContainerStatus: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Id", 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.Id = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Metadata", 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.Metadata == nil { m.Metadata = &ContainerMetadata{} } if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field State", wireType) } m.State = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.State |= ContainerState(b&0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType) } m.CreatedAt = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CreatedAt |= int64(b&0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field StartedAt", wireType) } m.StartedAt = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.StartedAt |= int64(b&0x7F) << shift if b < 0x80 { break } } case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field FinishedAt", wireType) } m.FinishedAt = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.FinishedAt |= int64(b&0x7F) << shift if b < 0x80 { break } } case 7: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ExitCode", wireType) } m.ExitCode = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ExitCode |= int32(b&0x7F) << shift if b < 0x80 { break } } case 8: 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 9: 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 case 10: 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 11: 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 case 12: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Labels", 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.Labels == nil { m.Labels = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := 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) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthApi } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthApi } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthApi } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthApi } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipApi(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthApi } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Labels[mapkey] = mapvalue iNdEx = postIndex case 13: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Annotations", 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.Annotations == nil { m.Annotations = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := 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) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthApi } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthApi } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthApi } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthApi } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipApi(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthApi } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Annotations[mapkey] = mapvalue iNdEx = postIndex case 14: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Mounts", 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.Mounts = append(m.Mounts, &Mount{}) if err := m.Mounts[len(m.Mounts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 15: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field LogPath", 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.LogPath = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 16: 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 = &ContainerResources{} } if err := m.Resources.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 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:]) 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 *ContainerStatusResponse) 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: ContainerStatusResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ContainerStatusResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Status", 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.Status == nil { m.Status = &ContainerStatus{} } if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Info", 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.Info == nil { m.Info = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := 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) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthApi } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthApi } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthApi } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthApi } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipApi(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthApi } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Info[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 *ContainerResources) 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: ContainerResources: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ContainerResources: 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 = &LinuxContainerResources{} } if err := m.Linux.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Windows", 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.Windows == nil { m.Windows = &WindowsContainerResources{} } if err := m.Windows.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 *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 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: UpdateContainerResourcesRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UpdateContainerResourcesRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", 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.ContainerId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: 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 = &LinuxContainerResources{} } if err := m.Linux.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Windows", 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.Windows == nil { m.Windows = &WindowsContainerResources{} } if err := m.Windows.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Annotations", 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.Annotations == nil { m.Annotations = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := 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) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthApi } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthApi } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthApi } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthApi } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipApi(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthApi } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } 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 *UpdateContainerResourcesResponse) 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: UpdateContainerResourcesResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UpdateContainerResourcesResponse: 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 *ExecSyncRequest) 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: ExecSyncRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ExecSyncRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", 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.ContainerId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cmd", 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.Cmd = append(m.Cmd, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Timeout", wireType) } m.Timeout = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Timeout |= int64(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 (m *ExecSyncResponse) 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: ExecSyncResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ExecSyncResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Stdout", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthApi } postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthApi } if postIndex > l { return io.ErrUnexpectedEOF } m.Stdout = append(m.Stdout[:0], dAtA[iNdEx:postIndex]...) if m.Stdout == nil { m.Stdout = []byte{} } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Stderr", wireType) } var byteLen int for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ byteLen |= int(b&0x7F) << shift if b < 0x80 { break } } if byteLen < 0 { return ErrInvalidLengthApi } postIndex := iNdEx + byteLen if postIndex < 0 { return ErrInvalidLengthApi } if postIndex > l { return io.ErrUnexpectedEOF } m.Stderr = append(m.Stderr[:0], dAtA[iNdEx:postIndex]...) if m.Stderr == nil { m.Stderr = []byte{} } iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ExitCode", wireType) } m.ExitCode = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ExitCode |= int32(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 (m *ExecRequest) 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: ExecRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ExecRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", 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.ContainerId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cmd", 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.Cmd = append(m.Cmd, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Tty", 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.Tty = bool(v != 0) case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Stdin", 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.Stdin = bool(v != 0) case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Stdout", 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.Stdout = bool(v != 0) case 6: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Stderr", 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.Stderr = bool(v != 0) 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 *ExecResponse) 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: ExecResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ExecResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Url", 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.Url = 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 *AttachRequest) 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: AttachRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: AttachRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", 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.ContainerId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Stdin", 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.Stdin = bool(v != 0) case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Tty", 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.Tty = bool(v != 0) case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Stdout", 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.Stdout = bool(v != 0) case 5: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Stderr", 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.Stderr = bool(v != 0) 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 *AttachResponse) 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: AttachResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: AttachResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Url", 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.Url = 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 *PortForwardRequest) 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: PortForwardRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PortForwardRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PodSandboxId", 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.PodSandboxId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType == 0 { var v int32 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= int32(b&0x7F) << shift if b < 0x80 { break } } m.Port = append(m.Port, 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.Port) == 0 { m.Port = make([]int32, 0, elementCount) } for iNdEx < postIndex { var v int32 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ v |= int32(b&0x7F) << shift if b < 0x80 { break } } m.Port = append(m.Port, v) } } else { return fmt.Errorf("proto: wrong wireType = %d for field Port", wireType) } 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 *PortForwardResponse) 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: PortForwardResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PortForwardResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Url", 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.Url = 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 *ImageFilter) 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: ImageFilter: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ImageFilter: 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 *ListImagesRequest) 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: ListImagesRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListImagesRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Filter", 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.Filter == nil { m.Filter = &ImageFilter{} } if err := m.Filter.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 *Image) 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: Image: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Image: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Id", 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.Id = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RepoTags", 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.RepoTags = append(m.RepoTags, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RepoDigests", 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.RepoDigests = append(m.RepoDigests, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 4: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Size_", wireType) } m.Size_ = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Size_ |= uint64(b&0x7F) << shift if b < 0x80 { break } } case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Uid", 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.Uid == nil { m.Uid = &Int64Value{} } if err := m.Uid.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Username", 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.Username = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Spec", 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.Spec == nil { m.Spec = &ImageSpec{} } if err := m.Spec.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 8: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Pinned", 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.Pinned = bool(v != 0) 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 *ListImagesResponse) 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: ListImagesResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListImagesResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Images", 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.Images = append(m.Images, &Image{}) if err := m.Images[len(m.Images)-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 *ImageStatusRequest) 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: ImageStatusRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ImageStatusRequest: 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 != 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:]) 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 *ImageStatusResponse) 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: ImageStatusResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ImageStatusResponse: 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 = &Image{} } 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 Info", 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.Info == nil { m.Info = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := 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) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthApi } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthApi } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthApi } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthApi } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipApi(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthApi } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Info[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 *AuthConfig) 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: AuthConfig: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: AuthConfig: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Username", 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.Username = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Password", 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.Password = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Auth", 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.Auth = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ServerAddress", 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.ServerAddress = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field IdentityToken", 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.IdentityToken = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RegistryToken", 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.RegistryToken = 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 *PullImageRequest) 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: 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: 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 PodCidr", 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.PodCidr = 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 *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 } 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: 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 wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field NetworkConfig", 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.NetworkConfig == nil { m.NetworkConfig = &NetworkConfig{} } if err := m.NetworkConfig.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 *UpdateRuntimeConfigRequest) 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: UpdateRuntimeConfigRequest: wiretype end group for non-group") } if fieldNum <= 0 { 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 RuntimeConfig", 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.RuntimeConfig == nil { m.RuntimeConfig = &RuntimeConfig{} } if err := m.RuntimeConfig.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 *UpdateRuntimeConfigResponse) 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: UpdateRuntimeConfigResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UpdateRuntimeConfigResponse: 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 *RuntimeCondition) 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: RuntimeCondition: wiretype end group for non-group") } if fieldNum <= 0 { 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 Type", 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.Type = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Status", 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.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 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 *RuntimeStatus) 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: RuntimeStatus: wiretype end group for non-group") } if fieldNum <= 0 { 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 Conditions", 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.Conditions = append(m.Conditions, &RuntimeCondition{}) if err := m.Conditions[len(m.Conditions)-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 *StatusRequest) 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: StatusRequest: wiretype end group for non-group") } if fieldNum <= 0 { 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:]) 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 *RuntimeHandlerFeatures) 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: RuntimeHandlerFeatures: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: RuntimeHandlerFeatures: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field RecursiveReadOnlyMounts", 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.RecursiveReadOnlyMounts = bool(v != 0) case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field UserNamespaces", 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.UserNamespaces = bool(v != 0) 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 *RuntimeHandler) 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: RuntimeHandler: wiretype end group for non-group") } if fieldNum <= 0 { 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 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 { 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 = &RuntimeHandlerFeatures{} } if err := m.Features.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 *RuntimeFeatures) 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: RuntimeFeatures: wiretype end group for non-group") } if fieldNum <= 0 { 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 SupplementalGroupsPolicy", 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.SupplementalGroupsPolicy = bool(v != 0) 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 *StatusResponse) 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: StatusResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: StatusResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Status", 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.Status == nil { m.Status = &RuntimeStatus{} } if err := m.Status.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Info", 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.Info == nil { m.Info = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := 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) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthApi } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthApi } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthApi } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthApi } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipApi(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthApi } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } 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:]) 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 *ImageFsInfoRequest) 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: ImageFsInfoRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ImageFsInfoRequest: 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 *UInt64Value) 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: UInt64Value: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: UInt64Value: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType) } m.Value = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Value |= uint64(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 (m *FilesystemIdentifier) 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: FilesystemIdentifier: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: FilesystemIdentifier: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Mountpoint", 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.Mountpoint = 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 *FilesystemUsage) 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: FilesystemUsage: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: FilesystemUsage: 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 FsId", 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.FsId == nil { m.FsId = &FilesystemIdentifier{} } if err := m.FsId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field UsedBytes", 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.UsedBytes == nil { m.UsedBytes = &UInt64Value{} } if err := m.UsedBytes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field InodesUsed", 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.InodesUsed == nil { m.InodesUsed = &UInt64Value{} } if err := m.InodesUsed.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 *WindowsFilesystemUsage) 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: WindowsFilesystemUsage: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WindowsFilesystemUsage: 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 FsId", 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.FsId == nil { m.FsId = &FilesystemIdentifier{} } if err := m.FsId.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field UsedBytes", 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.UsedBytes == nil { m.UsedBytes = &UInt64Value{} } if err := m.UsedBytes.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 *ImageFsInfoResponse) 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: ImageFsInfoResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ImageFsInfoResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ImageFilesystems", 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.ImageFilesystems = append(m.ImageFilesystems, &FilesystemUsage{}) if err := m.ImageFilesystems[len(m.ImageFilesystems)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil { 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:]) 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 *ContainerStatsRequest) 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: ContainerStatsRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ContainerStatsRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", 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.ContainerId = 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 *ContainerStatsResponse) 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: ContainerStatsResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ContainerStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Stats", 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.Stats == nil { m.Stats = &ContainerStats{} } if err := m.Stats.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 *ListContainerStatsRequest) 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: ListContainerStatsRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListContainerStatsRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Filter", 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.Filter == nil { m.Filter = &ContainerStatsFilter{} } if err := m.Filter.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 *ContainerStatsFilter) 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: ContainerStatsFilter: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ContainerStatsFilter: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Id", 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.Id = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PodSandboxId", 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.PodSandboxId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field LabelSelector", 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.LabelSelector == nil { m.LabelSelector = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := 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) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthApi } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthApi } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthApi } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthApi } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipApi(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthApi } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.LabelSelector[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 *ListContainerStatsResponse) 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: ListContainerStatsResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListContainerStatsResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Stats", 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.Stats = append(m.Stats, &ContainerStats{}) if err := m.Stats[len(m.Stats)-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 *ContainerAttributes) 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: ContainerAttributes: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ContainerAttributes: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Id", 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.Id = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Metadata", 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.Metadata == nil { m.Metadata = &ContainerMetadata{} } if err := m.Metadata.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Labels", 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.Labels == nil { m.Labels = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := 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) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthApi } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthApi } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthApi } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthApi } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipApi(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthApi } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } m.Labels[mapkey] = mapvalue iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Annotations", 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.Annotations == nil { m.Annotations = make(map[string]string) } var mapkey string var mapvalue string for iNdEx < postIndex { entryPreIndex := 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) if fieldNum == 1 { var stringLenmapkey uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapkey |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapkey := int(stringLenmapkey) if intStringLenmapkey < 0 { return ErrInvalidLengthApi } postStringIndexmapkey := iNdEx + intStringLenmapkey if postStringIndexmapkey < 0 { return ErrInvalidLengthApi } if postStringIndexmapkey > l { return io.ErrUnexpectedEOF } mapkey = string(dAtA[iNdEx:postStringIndexmapkey]) iNdEx = postStringIndexmapkey } else if fieldNum == 2 { var stringLenmapvalue uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ stringLenmapvalue |= uint64(b&0x7F) << shift if b < 0x80 { break } } intStringLenmapvalue := int(stringLenmapvalue) if intStringLenmapvalue < 0 { return ErrInvalidLengthApi } postStringIndexmapvalue := iNdEx + intStringLenmapvalue if postStringIndexmapvalue < 0 { return ErrInvalidLengthApi } if postStringIndexmapvalue > l { return io.ErrUnexpectedEOF } mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue]) iNdEx = postStringIndexmapvalue } else { iNdEx = entryPreIndex skippy, err := skipApi(dAtA[iNdEx:]) if err != nil { return err } if (skippy < 0) || (iNdEx+skippy) < 0 { return ErrInvalidLengthApi } if (iNdEx + skippy) > postIndex { return io.ErrUnexpectedEOF } iNdEx += skippy } } 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 *ContainerStats) 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: ContainerStats: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ContainerStats: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Attributes", 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.Attributes == nil { m.Attributes = &ContainerAttributes{} } if err := m.Attributes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cpu", 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.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.Memory.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field WritableLayer", 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.WritableLayer == nil { m.WritableLayer = &FilesystemUsage{} } if err := m.WritableLayer.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Swap", 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.Swap == nil { m.Swap = &SwapUsage{} } if err := m.Swap.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 *WindowsContainerStats) 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: WindowsContainerStats: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WindowsContainerStats: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Attributes", 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.Attributes == nil { m.Attributes = &ContainerAttributes{} } if err := m.Attributes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Cpu", 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.Cpu == nil { m.Cpu = &WindowsCpuUsage{} } 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 = &WindowsMemoryUsage{} } if err := m.Memory.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field WritableLayer", 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.WritableLayer == nil { m.WritableLayer = &WindowsFilesystemUsage{} } if err := m.WritableLayer.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 *CpuUsage) 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: CpuUsage: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CpuUsage: 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 UsageCoreNanoSeconds", 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.UsageCoreNanoSeconds == nil { m.UsageCoreNanoSeconds = &UInt64Value{} } if err := m.UsageCoreNanoSeconds.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field UsageNanoCores", 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.UsageNanoCores == nil { m.UsageNanoCores = &UInt64Value{} } if err := m.UsageNanoCores.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 *WindowsCpuUsage) 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: WindowsCpuUsage: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: WindowsCpuUsage: 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 UsageCoreNanoSeconds", 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.UsageCoreNanoSeconds == nil { m.UsageCoreNanoSeconds = &UInt64Value{} } if err := m.UsageCoreNanoSeconds.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field UsageNanoCores", 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.UsageNanoCores == nil { m.UsageNanoCores = &UInt64Value{} } if err := m.UsageNanoCores.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 *MemoryUsage) 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: MemoryUsage: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: MemoryUsage: 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.WorkingSetBytes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field AvailableBytes", 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.AvailableBytes == nil { m.AvailableBytes = &UInt64Value{} } if err := m.AvailableBytes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field UsageBytes", 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.UsageBytes == nil { m.UsageBytes = &UInt64Value{} } if err := m.UsageBytes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field RssBytes", 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.RssBytes == nil { m.RssBytes = &UInt64Value{} } if err := m.RssBytes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 6: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PageFaults", 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.PageFaults == nil { m.PageFaults = &UInt64Value{} } if err := m.PageFaults.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 7: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field MajorPageFaults", 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.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.WorkingSetBytes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field AvailableBytes", 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.AvailableBytes == nil { m.AvailableBytes = &UInt64Value{} } if err := m.AvailableBytes.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PageFaults", 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.PageFaults == nil { m.PageFaults = &UInt64Value{} } if err := m.PageFaults.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field CommitMemoryBytes", 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.CommitMemoryBytes == nil { m.CommitMemoryBytes = &UInt64Value{} } if err := m.CommitMemoryBytes.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 *ReopenContainerLogRequest) 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: ReopenContainerLogRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ReopenContainerLogRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", 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.ContainerId = 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 *ReopenContainerLogResponse) 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: ReopenContainerLogResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ReopenContainerLogResponse: 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 *CheckpointContainerRequest) 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: CheckpointContainerRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CheckpointContainerRequest: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", 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.ContainerId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Location", 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.Location = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field Timeout", wireType) } m.Timeout = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.Timeout |= int64(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 (m *CheckpointContainerResponse) 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: CheckpointContainerResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: CheckpointContainerResponse: 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 *GetEventsRequest) 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: GetEventsRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: GetEventsRequest: 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 *ContainerEventResponse) 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: ContainerEventResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ContainerEventResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", 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.ContainerId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerEventType", wireType) } m.ContainerEventType = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.ContainerEventType |= ContainerEventType(b&0x7F) << shift if b < 0x80 { break } } case 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field CreatedAt", wireType) } m.CreatedAt = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.CreatedAt |= int64(b&0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PodSandboxStatus", 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.PodSandboxStatus == nil { m.PodSandboxStatus = &PodSandboxStatus{} } if err := m.PodSandboxStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil { return err } iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainersStatuses", 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.ContainersStatuses = append(m.ContainersStatuses, &ContainerStatus{}) if err := m.ContainersStatuses[len(m.ContainersStatuses)-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 *ListMetricDescriptorsRequest) 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: ListMetricDescriptorsRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListMetricDescriptorsRequest: 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 *ListMetricDescriptorsResponse) 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: ListMetricDescriptorsResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListMetricDescriptorsResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Descriptors", 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.Descriptors = append(m.Descriptors, &MetricDescriptor{}) if err := m.Descriptors[len(m.Descriptors)-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 *MetricDescriptor) 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: MetricDescriptor: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: MetricDescriptor: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { 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 Help", 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.Help = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 3: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field LabelKeys", 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.LabelKeys = append(m.LabelKeys, 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 *ListPodSandboxMetricsRequest) 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: ListPodSandboxMetricsRequest: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListPodSandboxMetricsRequest: 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 *ListPodSandboxMetricsResponse) 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: ListPodSandboxMetricsResponse: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ListPodSandboxMetricsResponse: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PodMetrics", 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.PodMetrics = append(m.PodMetrics, &PodSandboxMetrics{}) if err := m.PodMetrics[len(m.PodMetrics)-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 *PodSandboxMetrics) 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: PodSandboxMetrics: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: PodSandboxMetrics: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field PodSandboxId", 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.PodSandboxId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Metrics", 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.Metrics = append(m.Metrics, &Metric{}) if err := m.Metrics[len(m.Metrics)-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 ContainerMetrics", 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.ContainerMetrics = append(m.ContainerMetrics, &ContainerMetrics{}) if err := m.ContainerMetrics[len(m.ContainerMetrics)-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 *ContainerMetrics) 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: ContainerMetrics: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: ContainerMetrics: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", 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.ContainerId = string(dAtA[iNdEx:postIndex]) iNdEx = postIndex case 2: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Metrics", 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.Metrics = append(m.Metrics, &Metric{}) if err := m.Metrics[len(m.Metrics)-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 *Metric) 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: Metric: wiretype end group for non-group") } if fieldNum <= 0 { return fmt.Errorf("proto: Metric: illegal tag %d (wire type %d)", fieldNum, wire) } switch fieldNum { case 1: if wireType != 2 { 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 != 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 3: if wireType != 0 { return fmt.Errorf("proto: wrong wireType = %d for field MetricType", wireType) } m.MetricType = 0 for shift := uint(0); ; shift += 7 { if shift >= 64 { return ErrIntOverflowApi } if iNdEx >= l { return io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ m.MetricType |= MetricType(b&0x7F) << shift if b < 0x80 { break } } case 4: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field LabelValues", 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.LabelValues = append(m.LabelValues, string(dAtA[iNdEx:postIndex])) iNdEx = postIndex case 5: if wireType != 2 { return fmt.Errorf("proto: wrong wireType = %d for field Value", 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.Value == nil { m.Value = &UInt64Value{} } if err := m.Value.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 *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 depth := 0 for iNdEx < l { var wire uint64 for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowApi } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ wire |= (uint64(b) & 0x7F) << shift if b < 0x80 { break } } wireType := int(wire & 0x7) switch wireType { case 0: for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowApi } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } iNdEx++ if dAtA[iNdEx-1] < 0x80 { break } } case 1: iNdEx += 8 case 2: var length int for shift := uint(0); ; shift += 7 { if shift >= 64 { return 0, ErrIntOverflowApi } if iNdEx >= l { return 0, io.ErrUnexpectedEOF } b := dAtA[iNdEx] iNdEx++ length |= (int(b) & 0x7F) << shift if b < 0x80 { break } } if length < 0 { return 0, ErrInvalidLengthApi } iNdEx += length case 3: depth++ case 4: if depth == 0 { return 0, ErrUnexpectedEndOfGroupApi } depth-- case 5: iNdEx += 4 default: return 0, fmt.Errorf("proto: illegal wireType %d", wireType) } if iNdEx < 0 { return 0, ErrInvalidLengthApi } if depth == 0 { return iNdEx, nil } } return 0, io.ErrUnexpectedEOF } var ( ErrInvalidLengthApi = fmt.Errorf("proto: negative length found during unmarshaling") ErrIntOverflowApi = fmt.Errorf("proto: integer overflow") ErrUnexpectedEndOfGroupApi = fmt.Errorf("proto: unexpected end of group") ) kubernetes-cri-api-4685890/pkg/apis/runtime/v1/api.proto000066400000000000000000002374021472465115100230160ustar00rootroot00000000000000/* Copyright 2020 The Kubernetes 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. */ // To regenerate api.pb.go run `hack/update-codegen.sh protobindings` syntax = "proto3"; package runtime.v1; option go_package = "k8s.io/cri-api/pkg/apis/runtime/v1"; import "github.com/gogo/protobuf/gogoproto/gogo.proto"; option (gogoproto.goproto_stringer_all) = false; option (gogoproto.stringer_all) = true; option (gogoproto.goproto_getters_all) = true; option (gogoproto.marshaler_all) = true; option (gogoproto.sizer_all) = true; option (gogoproto.unmarshaler_all) = true; option (gogoproto.goproto_unrecognized_all) = false; // Runtime service defines the public APIs for remote container runtimes service RuntimeService { // Version returns the runtime name, runtime version, and runtime API version. rpc Version(VersionRequest) returns (VersionResponse) {} // RunPodSandbox creates and starts a pod-level sandbox. Runtimes must ensure // the sandbox is in the ready state on success. rpc RunPodSandbox(RunPodSandboxRequest) returns (RunPodSandboxResponse) {} // StopPodSandbox stops any running process that is part of the sandbox and // reclaims network resources (e.g., IP addresses) allocated to the sandbox. // If there are any running containers in the sandbox, they must be forcibly // terminated. // This call is idempotent, and must not return an error if all relevant // resources have already been reclaimed. kubelet will call StopPodSandbox // at least once before calling RemovePodSandbox. It will also attempt to // reclaim resources eagerly, as soon as a sandbox is not needed. Hence, // multiple StopPodSandbox calls are expected. rpc StopPodSandbox(StopPodSandboxRequest) returns (StopPodSandboxResponse) {} // RemovePodSandbox removes the sandbox. If there are any running containers // in the sandbox, they must be forcibly terminated and removed. // This call is idempotent, and must not return an error if the sandbox has // already been removed. rpc RemovePodSandbox(RemovePodSandboxRequest) returns (RemovePodSandboxResponse) {} // PodSandboxStatus returns the status of the PodSandbox. If the PodSandbox is not // present, returns an error. rpc PodSandboxStatus(PodSandboxStatusRequest) returns (PodSandboxStatusResponse) {} // ListPodSandbox returns a list of PodSandboxes. rpc ListPodSandbox(ListPodSandboxRequest) returns (ListPodSandboxResponse) {} // CreateContainer creates a new container in specified PodSandbox rpc CreateContainer(CreateContainerRequest) returns (CreateContainerResponse) {} // StartContainer starts the container. rpc StartContainer(StartContainerRequest) returns (StartContainerResponse) {} // StopContainer stops a running container with a grace period (i.e., timeout). // This call is idempotent, and must not return an error if the container has // already been stopped. // The runtime must forcibly kill the container after the grace period is // reached. rpc StopContainer(StopContainerRequest) returns (StopContainerResponse) {} // RemoveContainer removes the container. If the container is running, the // container must be forcibly removed. // This call is idempotent, and must not return an error if the container has // already been removed. rpc RemoveContainer(RemoveContainerRequest) returns (RemoveContainerResponse) {} // ListContainers lists all containers by filters. rpc ListContainers(ListContainersRequest) returns (ListContainersResponse) {} // ContainerStatus returns status of the container. If the container is not // present, returns an error. rpc ContainerStatus(ContainerStatusRequest) returns (ContainerStatusResponse) {} // UpdateContainerResources updates ContainerConfig of the container synchronously. // If runtime fails to transactionally update the requested resources, an error is returned. rpc UpdateContainerResources(UpdateContainerResourcesRequest) returns (UpdateContainerResourcesResponse) {} // ReopenContainerLog asks runtime to reopen the stdout/stderr log file // for the container. This is often called after the log file has been // rotated. If the container is not running, container runtime can choose // to either create a new log file and return nil, or return an error. // Once it returns error, new container log file MUST NOT be created. rpc ReopenContainerLog(ReopenContainerLogRequest) returns (ReopenContainerLogResponse) {} // ExecSync runs a command in a container synchronously. rpc ExecSync(ExecSyncRequest) returns (ExecSyncResponse) {} // Exec prepares a streaming endpoint to execute a command in the container. rpc Exec(ExecRequest) returns (ExecResponse) {} // Attach prepares a streaming endpoint to attach to a running container. rpc Attach(AttachRequest) returns (AttachResponse) {} // PortForward prepares a streaming endpoint to forward ports from a PodSandbox. rpc PortForward(PortForwardRequest) returns (PortForwardResponse) {} // ContainerStats returns stats of the container. If the container does not // exist, the call returns an error. rpc ContainerStats(ContainerStatsRequest) returns (ContainerStatsResponse) {} // ListContainerStats returns stats of all running containers. rpc ListContainerStats(ListContainerStatsRequest) returns (ListContainerStatsResponse) {} // PodSandboxStats returns stats of the pod sandbox. If the pod sandbox does not // exist, the call returns an error. rpc PodSandboxStats(PodSandboxStatsRequest) returns (PodSandboxStatsResponse) {} // ListPodSandboxStats returns stats of the pod sandboxes matching a filter. rpc ListPodSandboxStats(ListPodSandboxStatsRequest) returns (ListPodSandboxStatsResponse) {} // UpdateRuntimeConfig updates the runtime configuration based on the given request. rpc UpdateRuntimeConfig(UpdateRuntimeConfigRequest) returns (UpdateRuntimeConfigResponse) {} // Status returns the status of the runtime. rpc Status(StatusRequest) returns (StatusResponse) {} // CheckpointContainer checkpoints a container rpc CheckpointContainer(CheckpointContainerRequest) returns (CheckpointContainerResponse) {} // GetContainerEvents gets container events from the CRI runtime 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 // adding or removing metrics descriptors, or they should not change. // Put differently, if ListPodSandboxMetrics references a name that is not described in the initial // ListMetricDescriptors call, then the metric will not be broadcasted. rpc ListMetricDescriptors(ListMetricDescriptorsRequest) returns (ListMetricDescriptorsResponse) {} // 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. service ImageService { // ListImages lists existing images. rpc ListImages(ListImagesRequest) returns (ListImagesResponse) {} // ImageStatus returns the status of the image. If the image is not // present, returns a response with ImageStatusResponse.Image set to // nil. rpc ImageStatus(ImageStatusRequest) returns (ImageStatusResponse) {} // PullImage pulls an image with authentication config. rpc PullImage(PullImageRequest) returns (PullImageResponse) {} // RemoveImage removes the image. // This call is idempotent, and must not return an error if the image has // already been removed. rpc RemoveImage(RemoveImageRequest) returns (RemoveImageResponse) {} // ImageFSInfo returns information of the filesystem that is used to store images. rpc ImageFsInfo(ImageFsInfoRequest) returns (ImageFsInfoResponse) {} } message VersionRequest { // Version of the kubelet runtime API. string version = 1; } message VersionResponse { // Version of the kubelet runtime API. string version = 1; // Name of the container runtime. string runtime_name = 2; // Version of the container runtime. The string must be // semver-compatible. string runtime_version = 3; // API version of the container runtime. The string must be // semver-compatible. string runtime_api_version = 4; } // DNSConfig specifies the DNS servers and search domains of a sandbox. message DNSConfig { // List of DNS servers of the cluster. repeated string servers = 1; // List of DNS search domains of the cluster. repeated string searches = 2; // List of DNS options. See https://linux.die.net/man/5/resolv.conf // for all available options. repeated string options = 3; } enum Protocol { TCP = 0; UDP = 1; SCTP = 2; } // PortMapping specifies the port mapping configurations of a sandbox. message PortMapping { // Protocol of the port mapping. Protocol protocol = 1; // Port number within the container. Default: 0 (not specified). int32 container_port = 2; // Port number on the host. Default: 0 (not specified). int32 host_port = 3; // Host IP. string host_ip = 4; } enum MountPropagation { // 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; // Mounts get propagated from the host to the container and from the // container to the host ("rshared" in Linux). PROPAGATION_BIDIRECTIONAL = 2; } // Mount specifies a host volume to mount into a container. message Mount { // Path of the mount within the container. string container_path = 1; // Path of the mount on the host. Has to be empty if the image field below // is provided, because those fields are mutually exclusive. If the image // field below is nil and the host path doesn't exist, then runtimes should // report an error. If the hostpath is a symbolic link, runtimes should // follow the symlink and mount the real destination to container. string host_path = 2; // If set, the mount is read-only. bool readonly = 3; // If set, the mount needs SELinux relabeling. bool selinux_relabel = 4; // Requested propagation mode. MountPropagation propagation = 5; // UidMappings specifies the runtime UID mappings for the 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. message IDMapping { // HostId is the id on the host. uint32 host_id = 1; // ContainerId is the id in the container. uint32 container_id = 2; // Length is the size of the range to map. uint32 length = 3; } // A NamespaceMode describes the intended namespace configuration for each // of the namespaces (Network, PID, IPC) in NamespaceOption. Runtimes should // map these modes as appropriate for the technology underlying the runtime. enum NamespaceMode { // A POD namespace is common to all containers in a pod. // For example, a container with a PID namespace of POD expects to view // all of the processes in all of the containers in the pod. POD = 0; // A CONTAINER namespace is restricted to a single container. // For example, a container with a PID namespace of CONTAINER expects to // view only the processes in that container. CONTAINER = 1; // A NODE namespace is the namespace of the Kubernetes node. // For example, a container with a PID namespace of NODE expects to view // all of the processes on the host running the kubelet. NODE = 2; // TARGET targets the namespace of another container. When this is specified, // a target_id must be specified in NamespaceOption and refer to a container // previously created with NamespaceMode CONTAINER. This containers namespace // will be made to match that of container target_id. // For example, a container with a PID namespace of TARGET expects to view // all of the processes that container target_id can view. TARGET = 3; } // UserNamespace describes the intended user namespace configuration for a pod sandbox. message UserNamespace { // Mode is the NamespaceMode for this UserNamespace. // Note: NamespaceMode for UserNamespace currently supports only POD and NODE, not CONTAINER OR TARGET. NamespaceMode mode = 1; // Uids specifies the UID mappings for the user namespace. repeated IDMapping uids = 2; // Gids specifies the GID mappings for the user namespace. repeated IDMapping gids = 3; } // NamespaceOption provides options for Linux namespaces. message NamespaceOption { // Network namespace for this container/sandbox. // Note: There is currently no way to set CONTAINER scoped network in the Kubernetes API. // Namespaces currently set by the kubelet: POD, NODE NamespaceMode network = 1; // PID namespace for this container/sandbox. // Note: The CRI default is POD, but the v1.PodSpec default is CONTAINER. // The kubelet's runtime manager will set this to CONTAINER explicitly for v1 pods. // Namespaces currently set by the kubelet: POD, CONTAINER, NODE, TARGET NamespaceMode pid = 2; // IPC namespace for this container/sandbox. // Note: There is currently no way to set CONTAINER scoped IPC in the Kubernetes API. // Namespaces currently set by the kubelet: POD, NODE NamespaceMode ipc = 3; // Target Container ID for NamespaceMode of TARGET. This container must have been // previously created in the same pod. It is not possible to specify different targets // for each namespace. string target_id = 4; // UsernsOptions for this pod sandbox. // The Kubelet picks the user namespace configuration to use for the pod sandbox. The mappings // are specified as part of the UserNamespace struct. If the struct is nil, then the POD mode // must be assumed. This is done for backward compatibility with older Kubelet versions that // do not set a user namespace. 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. int64 value = 1; } // LinuxSandboxSecurityContext holds linux security configuration that will be // applied to a sandbox. Note that: // 1) It does not apply to containers in the pods. // 2) It may not be applicable to a PodSandbox which does not contain any running // process. message LinuxSandboxSecurityContext { // Configurations for the sandbox's namespaces. // This will be used only if the PodSandbox uses namespace for isolation. NamespaceOption namespace_options = 1; // Optional SELinux context to be applied. SELinuxOption selinux_options = 2; // UID to run sandbox processes as, when applicable. Int64Value run_as_user = 3; // GID to run sandbox processes as, when applicable. run_as_group should only // be specified when run_as_user is specified; otherwise, the runtime MUST error. 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 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. // This allows a sandbox to take additional security precautions if no // privileged containers are expected to be run. bool privileged = 6; // Seccomp profile for the sandbox. SecurityProfile seccomp = 9; // AppArmor profile for the sandbox. SecurityProfile apparmor = 10; // Seccomp profile for the sandbox, candidate values are: // * runtime/default: the default profile for the container runtime // * unconfined: unconfined profile, ie, no seccomp sandboxing // * localhost/: the profile installed on the node. // is the full path of the profile. // Default: "", which is identical with unconfined. string seccomp_profile_path = 7 [deprecated=true]; } // A security profile which can be used for sandboxes and containers. message SecurityProfile { // Available profile types. enum ProfileType { // The container runtime default profile should be used. RuntimeDefault = 0; // Disable the feature for the sandbox or the container. Unconfined = 1; // A pre-defined profile on the node should be used. Localhost = 2; } // Indicator which `ProfileType` should be applied. ProfileType profile_type = 1; // Indicates that a pre-defined profile on the node should be used. // Must only be set if `ProfileType` is `Localhost`. // For seccomp, it must be an absolute path to the seccomp profile. // For AppArmor, this field is the AppArmor `/` string localhost_ref = 2; } // LinuxPodSandboxConfig holds platform-specific configurations for Linux // host platforms and Linux-based containers. message LinuxPodSandboxConfig { // Parent cgroup of the PodSandbox. // The cgroupfs style syntax will be used, but the container runtime can // convert it to systemd semantics if needed. string cgroup_parent = 1; // LinuxSandboxSecurityContext holds sandbox security attributes. LinuxSandboxSecurityContext security_context = 2; // Sysctls holds linux sysctls config for the sandbox. map sysctls = 3; // Optional overhead represents the overheads associated with this sandbox LinuxContainerResources overhead = 4; // Optional resources represents the sum of container resources for this sandbox LinuxContainerResources resources = 5; } // PodSandboxMetadata holds all necessary information for building the sandbox name. // The container runtime is encouraged to expose the metadata associated with the // PodSandbox in its user interface for better user experience. For example, // the runtime can construct a unique PodSandboxName based on the metadata. message PodSandboxMetadata { // Pod name of the sandbox. Same as the pod name in the Pod ObjectMeta. string name = 1; // Pod UID of the sandbox. Same as the pod UID in the Pod ObjectMeta. string uid = 2; // Pod namespace of the sandbox. Same as the pod namespace in the Pod ObjectMeta. string namespace = 3; // Attempt number of creating the sandbox. Default: 0. uint32 attempt = 4; } // PodSandboxConfig holds all the required and optional fields for creating a // sandbox. message PodSandboxConfig { // Metadata of the sandbox. This information will uniquely identify the // sandbox, and the runtime should leverage this to ensure correct // operation. The runtime may also use this information to improve UX, such // as by constructing a readable name. PodSandboxMetadata metadata = 1; // Hostname of the sandbox. Hostname could only be empty when the pod // network namespace is NODE. string hostname = 2; // Path to the directory on the host in which container log files are // stored. // By default the log of a container going into the LogDirectory will be // hooked up to STDOUT and STDERR. However, the LogDirectory may contain // binary log files with structured logging data from the individual // containers. For example, the files might be newline separated JSON // structured logs, systemd-journald journal files, gRPC trace files, etc. // E.g., // PodSandboxConfig.LogDirectory = `/var/log/pods/__/` // ContainerConfig.LogPath = `containerName/Instance#.log` string log_directory = 3; // DNS config for the sandbox. DNSConfig dns_config = 4; // Port mappings for the sandbox. repeated PortMapping port_mappings = 5; // Key-value pairs that may be used to scope and select individual resources. map labels = 6; // Unstructured key-value map that may be set by the kubelet to store and // retrieve arbitrary metadata. This will include any annotations set on a // pod through the Kubernetes API. // // Annotations MUST NOT be altered by the runtime; the annotations stored // here MUST be returned in the PodSandboxStatus associated with the pod // this PodSandboxConfig creates. // // In general, in order to preserve a well-defined interface between the // kubelet and the container runtime, annotations SHOULD NOT influence // runtime behaviour. // // Annotations can also be useful for runtime authors to experiment with // new features that are opaque to the Kubernetes APIs (both user-facing // and the CRI). Whenever possible, however, runtime authors SHOULD // consider proposing new typed fields for any new features instead. map annotations = 7; // Optional configurations specific to Linux hosts. LinuxPodSandboxConfig linux = 8; // Optional configurations specific to Windows hosts. WindowsPodSandboxConfig windows = 9; } message RunPodSandboxRequest { // Configuration for creating a PodSandbox. PodSandboxConfig config = 1; // Named runtime configuration to use for this PodSandbox. // If the runtime handler is unknown, this request should be rejected. An // empty string should select the default handler, equivalent to the // behavior before this feature was added. // See https://git.k8s.io/enhancements/keps/sig-node/585-runtime-class string runtime_handler = 2; } message RunPodSandboxResponse { // ID of the PodSandbox to run. string pod_sandbox_id = 1; } message StopPodSandboxRequest { // ID of the PodSandbox to stop. string pod_sandbox_id = 1; } message StopPodSandboxResponse {} message RemovePodSandboxRequest { // ID of the PodSandbox to remove. string pod_sandbox_id = 1; } message RemovePodSandboxResponse {} message PodSandboxStatusRequest { // ID of the PodSandbox for which to retrieve status. string pod_sandbox_id = 1; // Verbose indicates whether to return extra information about the pod sandbox. bool verbose = 2; } // PodIP represents an ip of a Pod message PodIP{ // an ip is a string representation of an IPv4 or an IPv6 string ip = 1; } // PodSandboxNetworkStatus is the status of the network for a PodSandbox. // Currently ignored for pods sharing the host networking namespace. message PodSandboxNetworkStatus { // IP address of the PodSandbox. string ip = 1; // list of additional ips (not inclusive of PodSandboxNetworkStatus.Ip) of the PodSandBoxNetworkStatus repeated PodIP additional_ips = 2; } // Namespace contains paths to the namespaces. message Namespace { // Namespace options for Linux namespaces. NamespaceOption options = 2; } // LinuxSandboxStatus contains status specific to Linux sandboxes. message LinuxPodSandboxStatus { // Paths to the sandbox's namespaces. Namespace namespaces = 1; } enum PodSandboxState { SANDBOX_READY = 0; SANDBOX_NOTREADY = 1; } // PodSandboxStatus contains the status of the PodSandbox. message PodSandboxStatus { // ID of the sandbox. string id = 1; // Metadata of the sandbox. PodSandboxMetadata metadata = 2; // State of the sandbox. PodSandboxState state = 3; // Creation timestamp of the sandbox in nanoseconds. Must be > 0. int64 created_at = 4; // Network contains network status if network is handled by the runtime. PodSandboxNetworkStatus network = 5; // Linux-specific status to a pod sandbox. LinuxPodSandboxStatus linux = 6; // Labels are key-value pairs that may be used to scope and select individual resources. map labels = 7; // Unstructured key-value map holding arbitrary metadata. // Annotations MUST NOT be altered by the runtime; the value of this field // MUST be identical to that of the corresponding PodSandboxConfig used to // instantiate the pod sandbox this status represents. map annotations = 8; // runtime configuration used for this PodSandbox. string runtime_handler = 9; } message PodSandboxStatusResponse { // Status of the PodSandbox. PodSandboxStatus status = 1; // Info is extra information of the PodSandbox. The key could be arbitrary string, and // value should be in json format. The information could include anything useful for // debug, e.g. network namespace for linux container based container runtime. // It should only be returned non-empty when Verbose is true. map info = 2; // Container statuses repeated ContainerStatus containers_statuses = 3; // Timestamp in nanoseconds at which container and pod statuses were recorded int64 timestamp = 4; } // PodSandboxStateValue is the wrapper of PodSandboxState. message PodSandboxStateValue { // State of the sandbox. PodSandboxState state = 1; } // PodSandboxFilter is used to filter a list of PodSandboxes. // All those fields are combined with 'AND' message PodSandboxFilter { // ID of the sandbox. string id = 1; // State of the sandbox. PodSandboxStateValue state = 2; // LabelSelector to select matches. // Only api.MatchLabels is supported for now and the requirements // are ANDed. MatchExpressions is not supported yet. map label_selector = 3; } message ListPodSandboxRequest { // PodSandboxFilter to filter a list of PodSandboxes. PodSandboxFilter filter = 1; } // PodSandbox contains minimal information about a sandbox. message PodSandbox { // ID of the PodSandbox. string id = 1; // Metadata of the PodSandbox. PodSandboxMetadata metadata = 2; // State of the PodSandbox. PodSandboxState state = 3; // Creation timestamps of the PodSandbox in nanoseconds. Must be > 0. int64 created_at = 4; // Labels of the PodSandbox. map labels = 5; // Unstructured key-value map holding arbitrary metadata. // Annotations MUST NOT be altered by the runtime; the value of this field // MUST be identical to that of the corresponding PodSandboxConfig used to // instantiate this PodSandbox. map annotations = 6; // runtime configuration used for this PodSandbox. string runtime_handler = 7; } message ListPodSandboxResponse { // List of PodSandboxes. repeated PodSandbox items = 1; } message PodSandboxStatsRequest { // ID of the pod sandbox for which to retrieve stats. string pod_sandbox_id = 1; } message PodSandboxStatsResponse { PodSandboxStats stats = 1; } // PodSandboxStatsFilter is used to filter the list of pod sandboxes to retrieve stats for. // All those fields are combined with 'AND'. message PodSandboxStatsFilter { // ID of the pod sandbox. string id = 1; // LabelSelector to select matches. // Only api.MatchLabels is supported for now and the requirements // are ANDed. MatchExpressions is not supported yet. map label_selector = 2; } message ListPodSandboxStatsRequest { // Filter for the list request. PodSandboxStatsFilter filter = 1; } message ListPodSandboxStatsResponse { // Stats of the pod sandbox. repeated PodSandboxStats stats = 1; } // PodSandboxAttributes provides basic information of the pod sandbox. message PodSandboxAttributes { // ID of the pod sandbox. string id = 1; // Metadata of the pod sandbox. PodSandboxMetadata metadata = 2; // Key-value pairs that may be used to scope and select individual resources. map labels = 3; // Unstructured key-value map holding arbitrary metadata. // Annotations MUST NOT be altered by the runtime; the value of this field // MUST be identical to that of the corresponding PodSandboxStatus used to // instantiate the PodSandbox this status represents. map annotations = 4; } // PodSandboxStats provides the resource usage statistics for a pod. // The linux or windows field will be populated depending on the platform. message PodSandboxStats { // Information of the pod. PodSandboxAttributes attributes = 1; // Stats from linux. LinuxPodSandboxStats linux = 2; // Stats from windows. WindowsPodSandboxStats windows = 3; } // LinuxPodSandboxStats provides the resource usage statistics for a pod sandbox on linux. message LinuxPodSandboxStats { // CPU usage gathered for the pod sandbox. CpuUsage cpu = 1; // Memory usage gathered for the pod sandbox. MemoryUsage memory = 2; // Network usage gathered for the pod sandbox NetworkUsage network = 3; // Stats pertaining to processes in the pod sandbox. ProcessUsage process = 4; // Stats of containers in the measured pod sandbox. repeated ContainerStats containers = 5; } // WindowsPodSandboxStats provides the resource usage statistics for a pod sandbox on windows message WindowsPodSandboxStats { // CPU usage gathered for the pod sandbox. WindowsCpuUsage cpu = 1; // Memory usage gathered for the pod sandbox. WindowsMemoryUsage memory = 2; // Network usage gathered for the pod sandbox WindowsNetworkUsage network = 3; // Stats pertaining to processes in the pod sandbox. WindowsProcessUsage process = 4; // Stats of containers in the measured pod sandbox. repeated WindowsContainerStats containers = 5; } // NetworkUsage contains data about network resources. message NetworkUsage { // Timestamp in nanoseconds at which the information were collected. Must be > 0. int64 timestamp = 1; // Stats for the default network interface. NetworkInterfaceUsage default_interface = 2; // Stats for all found network interfaces, excluding the default. repeated NetworkInterfaceUsage interfaces = 3; } // WindowsNetworkUsage contains data about network resources specific to Windows. message WindowsNetworkUsage { // Timestamp in nanoseconds at which the information were collected. Must be > 0. int64 timestamp = 1; // Stats for the default network interface. WindowsNetworkInterfaceUsage default_interface = 2; // Stats for all found network interfaces, excluding the default. repeated WindowsNetworkInterfaceUsage interfaces = 3; } // NetworkInterfaceUsage contains resource value data about a network interface. message NetworkInterfaceUsage { // The name of the network interface. string name = 1; // Cumulative count of bytes received. UInt64Value rx_bytes = 2; // Cumulative count of receive errors encountered. UInt64Value rx_errors = 3; // Cumulative count of bytes transmitted. UInt64Value tx_bytes = 4; // Cumulative count of transmit errors encountered. UInt64Value tx_errors = 5; } // WindowsNetworkInterfaceUsage contains resource value data about a network interface specific for Windows. message WindowsNetworkInterfaceUsage { // The name of the network interface. string name = 1; // Cumulative count of bytes received. UInt64Value rx_bytes = 2; // Cumulative count of receive errors encountered. UInt64Value rx_packets_dropped = 3; // Cumulative count of bytes transmitted. UInt64Value tx_bytes = 4; // Cumulative count of transmit errors encountered. UInt64Value tx_packets_dropped = 5; } // ProcessUsage are stats pertaining to processes. message ProcessUsage { // Timestamp in nanoseconds at which the information were collected. Must be > 0. int64 timestamp = 1; // Number of processes. UInt64Value process_count = 2; } // WindowsProcessUsage are stats pertaining to processes specific to Windows. message WindowsProcessUsage { // Timestamp in nanoseconds at which the information were collected. Must be > 0. int64 timestamp = 1; // Number of processes. UInt64Value process_count = 2; } // ImageSpec is an internal representation of an image. message ImageSpec { // Container's Image field (e.g. imageID or imageDigest). string image = 1; // Unstructured key-value map holding arbitrary metadata. // 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 { string key = 1; string value = 2; } // LinuxContainerResources specifies Linux specific configuration for // resources. message LinuxContainerResources { // CPU CFS (Completely Fair Scheduler) period. Default: 0 (not specified). int64 cpu_period = 1; // CPU CFS (Completely Fair Scheduler) quota. Default: 0 (not specified). int64 cpu_quota = 2; // CPU shares (relative weight vs. other containers). Default: 0 (not specified). int64 cpu_shares = 3; // Memory limit in bytes. Default: 0 (not specified). int64 memory_limit_in_bytes = 4; // OOMScoreAdj adjusts the oom-killer score. Default: 0 (not specified). int64 oom_score_adj = 5; // CpusetCpus constrains the allowed set of logical CPUs. Default: "" (not specified). string cpuset_cpus = 6; // CpusetMems constrains the allowed set of memory nodes. Default: "" (not specified). string cpuset_mems = 7; // List of HugepageLimits to limit the HugeTLB usage of container per page size. Default: nil (not specified). repeated HugepageLimit hugepage_limits = 8; // Unified resources for cgroup v2. Default: nil (not specified). // Each key/value in the map refers to the cgroup v2. // e.g. "memory.max": "6937202688" or "io.weight": "default 100". map unified = 9; // Memory swap limit in bytes. Default 0 (not specified). int64 memory_swap_limit_in_bytes = 10; } // HugepageLimit corresponds to the file`hugetlb..limit_in_byte` in container level cgroup. // For example, `PageSize=1GB`, `Limit=1073741824` means setting `1073741824` bytes to hugetlb.1GB.limit_in_bytes. message HugepageLimit { // The value of PageSize has the format B (2MB, 1GB), // and must match the of the corresponding control file found in `hugetlb..limit_in_bytes`. // The values of are intended to be parsed using base 1024("1KB" = 1024, "1MB" = 1048576, etc). string page_size = 1; // limit in bytes of hugepagesize HugeTLB usage. uint64 limit = 2; } // SELinuxOption are the labels to be applied to the container. message SELinuxOption { string user = 1; string role = 2; string type = 3; string level = 4; } // Capability contains the container capabilities to add or drop // Dropping a capability will drop it from all sets. // If a capability is added to only the add_capabilities list then it gets added to permitted, // inheritable, effective and bounding sets, i.e. all sets except the ambient set. // If a capability is added to only the add_ambient_capabilities list then it gets added to all sets, i.e permitted // inheritable, effective, bounding and ambient sets. // If a capability is added to add_capabilities and add_ambient_capabilities lists then it gets added to all sets, i.e. // permitted, inheritable, effective, bounding and ambient sets. message Capability { // List of capabilities to add. repeated string add_capabilities = 1; // List of capabilities to drop. repeated string drop_capabilities = 2; // List of ambient capabilities to add. repeated string add_ambient_capabilities = 3; } // LinuxContainerSecurityContext holds linux security configuration that will be applied to a container. message LinuxContainerSecurityContext { // Capabilities to add or drop. Capability capabilities = 1; // If set, run container in privileged mode. // Privileged mode is incompatible with the following options. If // privileged is set, the following features MAY have no effect: // 1. capabilities // 2. selinux_options // 4. seccomp // 5. apparmor // // Privileged mode implies the following specific options are applied: // 1. All capabilities are added. // 2. Sensitive paths, such as kernel module paths within sysfs, are not masked. // 3. Any sysfs and procfs mounts are mounted RW. // 4. AppArmor confinement is not applied. // 5. Seccomp restrictions are not applied. // 6. The device cgroup does not restrict access to any devices. // 7. All devices from the host's /dev are available within the container. // 8. SELinux restrictions are not applied (e.g. label=disabled). bool privileged = 2; // Configurations for the container's namespaces. // Only used if the container uses namespace for isolation. NamespaceOption namespace_options = 3; // SELinux context to be optionally applied. SELinuxOption selinux_options = 4; // UID to run the container process as. Only one of run_as_user and // run_as_username can be specified at a time. Int64Value run_as_user = 5; // GID to run the container process as. run_as_group should only be specified // when run_as_user or run_as_username is specified; otherwise, the runtime // MUST error. Int64Value run_as_group = 12; // User name to run the container process as. If specified, the user MUST // exist in the container image (i.e. in the /etc/passwd inside the image), // and be resolved there by the runtime; otherwise, the runtime MUST error. 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 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; // masked_paths is a slice of paths that should be masked by the container // runtime, this can be passed directly to the OCI spec. repeated string masked_paths = 13; // readonly_paths is a slice of paths that should be set as readonly by the // container runtime, this can be passed directly to the OCI spec. repeated string readonly_paths = 14; // Seccomp profile for the container. SecurityProfile seccomp = 15; // AppArmor profile for the container. SecurityProfile apparmor = 16; // AppArmor profile for the container, candidate values are: // * runtime/default: equivalent to not specifying a profile. // * unconfined: no profiles are loaded // * localhost/: profile loaded on the node // (localhost) by name. The possible profile names are detailed at // https://gitlab.com/apparmor/apparmor/-/wikis/AppArmor_Core_Policy_Reference string apparmor_profile = 9 [deprecated=true]; // Seccomp profile for the container, candidate values are: // * runtime/default: the default profile for the container runtime // * unconfined: unconfined profile, ie, no seccomp sandboxing // * localhost/: the profile installed on the node. // is the full path of the profile. // Default: "", which is identical with unconfined. string seccomp_profile_path = 10 [deprecated=true]; } // LinuxContainerConfig contains platform-specific configuration for // Linux-based containers. message LinuxContainerConfig { // Resources specification for the container. LinuxContainerResources resources = 1; // LinuxContainerSecurityContext configuration for the container. 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. // Namespaces currently set by the kubelet: POD, NODE NamespaceMode network = 1; } // WindowsSandboxSecurityContext holds platform-specific configurations that will be // applied to a sandbox. // These settings will only apply to the sandbox container. message WindowsSandboxSecurityContext { // User name to run the container process as. If specified, the user MUST // exist in the container image and be resolved there by the runtime; // otherwise, the runtime MUST return error. string run_as_username = 1; // The contents of the GMSA credential spec to use to run this container. string credential_spec = 2; // Indicates whether the container requested to run as a HostProcess container. bool host_process = 3; // Configuration for the sandbox's namespaces WindowsNamespaceOption namespace_options = 4; } // WindowsPodSandboxConfig holds platform-specific configurations for Windows // host platforms and Windows-based containers. message WindowsPodSandboxConfig { // WindowsSandboxSecurityContext holds sandbox security attributes. WindowsSandboxSecurityContext security_context = 1; } // WindowsContainerSecurityContext holds windows security configuration that will be applied to a container. message WindowsContainerSecurityContext { // User name to run the container process as. If specified, the user MUST // exist in the container image and be resolved there by the runtime; // otherwise, the runtime MUST return error. string run_as_username = 1; // The contents of the GMSA credential spec to use to run this container. string credential_spec = 2; // Indicates whether a container is to be run as a HostProcess container. bool host_process = 3; } // WindowsContainerConfig contains platform-specific configuration for // Windows-based containers. message WindowsContainerConfig { // Resources specification for the container. WindowsContainerResources resources = 1; // WindowsContainerSecurityContext configuration for the container. WindowsContainerSecurityContext security_context = 2; } // WindowsContainerResources specifies Windows specific configuration for // resources. message WindowsContainerResources { // CPU shares (relative weight vs. other containers). Default: 0 (not specified). int64 cpu_shares = 1; // Number of CPUs available to the container. Default: 0 (not specified). int64 cpu_count = 2; // Specifies the portion of processor cycles that this container can use as a percentage times 100. int64 cpu_maximum = 3; // Memory limit in bytes. Default: 0 (not specified). int64 memory_limit_in_bytes = 4; // Specifies the size of the rootfs / scratch space in bytes to be configured for this container. Default: 0 (not specified). int64 rootfs_size_in_bytes = 5; // Optionally specifies the set of CPUs to affinitize for this container. repeated WindowsCpuGroupAffinity affinity_cpus = 6; } // WindowsCpuGroupAffinity specifies the CPU mask and group to affinitize. // This is similar to the following _GROUP_AFFINITY structure: // https://learn.microsoft.com/en-us/windows-hardware/drivers/ddi/miniport/ns-miniport-_group_affinity message WindowsCpuGroupAffinity { // CPU mask relative to this CPU group. uint64 cpu_mask = 1; // Processor group the mask refers to, as returned by // GetLogicalProcessorInformationEx. uint32 cpu_group = 2; } // ContainerMetadata holds all necessary information for building the container // name. The container runtime is encouraged to expose the metadata in its user // interface for better user experience. E.g., runtime can construct a unique // container name based on the metadata. Note that (name, attempt) is unique // within a sandbox for the entire lifetime of the sandbox. message ContainerMetadata { // Name of the container. Same as the container name in the PodSpec. string name = 1; // Attempt number of creating the container. Default: 0. uint32 attempt = 2; } // Device specifies a host device to mount into a container. message Device { // Path of the device within the container. string container_path = 1; // Path of the device on the host. string host_path = 2; // Cgroups permissions of the device, candidates are one or more of // * r - allows container to read from the specified device. // * w - allows container to write to the specified device. // * m - allows container to create device files that do not yet exist. string permissions = 3; } // CDIDevice specifies a CDI device information. message CDIDevice { // Fully qualified CDI device name // for example: vendor.com/gpu=gpudevice1 // see more details in the CDI specification: // https://github.com/container-orchestrated-devices/container-device-interface/blob/main/SPEC.md string name = 1; } // ContainerConfig holds all the required and optional fields for creating a // container. message ContainerConfig { // Metadata of the container. This information will uniquely identify the // container, and the runtime should leverage this to ensure correct // operation. The runtime may also use this information to improve UX, such // as by constructing a readable name. ContainerMetadata metadata = 1 ; // Image to use. ImageSpec image = 2; // Command to execute (i.e., entrypoint for docker) repeated string command = 3; // Args for the Command (i.e., command for docker) repeated string args = 4; // Current working directory of the command. string working_dir = 5; // List of environment variable to set in the container. repeated KeyValue envs = 6; // Mounts for the container. repeated Mount mounts = 7; // Devices for the container. repeated Device devices = 8; // Key-value pairs that may be used to scope and select individual resources. // Label keys are of the form: // label-key ::= prefixed-name | name // prefixed-name ::= prefix '/' name // prefix ::= DNS_SUBDOMAIN // name ::= DNS_LABEL map labels = 9; // Unstructured key-value map that may be used by the kubelet to store and // retrieve arbitrary metadata. // // Annotations MUST NOT be altered by the runtime; the annotations stored // here MUST be returned in the ContainerStatus associated with the container // this ContainerConfig creates. // // In general, in order to preserve a well-defined interface between the // kubelet and the container runtime, annotations SHOULD NOT influence // runtime behaviour. map annotations = 10; // Path relative to PodSandboxConfig.LogDirectory for container to store // the log (STDOUT and STDERR) on the host. // E.g., // PodSandboxConfig.LogDirectory = `/var/log/pods/__/` // ContainerConfig.LogPath = `containerName/Instance#.log` string log_path = 11; // Variables for interactive containers, these have very specialized // use-cases (e.g. debugging). bool stdin = 12; bool stdin_once = 13; bool tty = 14; // Configuration specific to Linux containers. LinuxContainerConfig linux = 15; // Configuration specific to Windows containers. WindowsContainerConfig windows = 16; // CDI devices for the container. repeated CDIDevice CDI_devices = 17; } message CreateContainerRequest { // ID of the PodSandbox in which the container should be created. string pod_sandbox_id = 1; // Config of the container. ContainerConfig config = 2; // Config of the PodSandbox. This is the same config that was passed // to RunPodSandboxRequest to create the PodSandbox. It is passed again // here just for easy reference. The PodSandboxConfig is immutable and // remains the same throughout the lifetime of the pod. PodSandboxConfig sandbox_config = 3; } message CreateContainerResponse { // ID of the created container. string container_id = 1; } message StartContainerRequest { // ID of the container to start. string container_id = 1; } message StartContainerResponse {} message StopContainerRequest { // ID of the container to stop. string container_id = 1; // Timeout in seconds to wait for the container to stop before forcibly // terminating it. Default: 0 (forcibly terminate the container immediately) int64 timeout = 2; } message StopContainerResponse {} message RemoveContainerRequest { // ID of the container to remove. string container_id = 1; } message RemoveContainerResponse {} enum ContainerState { CONTAINER_CREATED = 0; CONTAINER_RUNNING = 1; CONTAINER_EXITED = 2; CONTAINER_UNKNOWN = 3; } // ContainerStateValue is the wrapper of ContainerState. message ContainerStateValue { // State of the container. ContainerState state = 1; } // ContainerFilter is used to filter containers. // All those fields are combined with 'AND' message ContainerFilter { // ID of the container. string id = 1; // State of the container. ContainerStateValue state = 2; // ID of the PodSandbox. string pod_sandbox_id = 3; // LabelSelector to select matches. // Only api.MatchLabels is supported for now and the requirements // are ANDed. MatchExpressions is not supported yet. map label_selector = 4; } message ListContainersRequest { ContainerFilter filter = 1; } // Container provides the runtime information for a container, such as ID, hash, // state of the container. message Container { // ID of the container, used by the container runtime to identify // a container. string id = 1; // ID of the sandbox to which this container belongs. string pod_sandbox_id = 2; // Metadata of the container. ContainerMetadata metadata = 3; // Spec of the image. ImageSpec image = 4; // Digested reference to the image in use. string image_ref = 5; // State of the container. ContainerState state = 6; // Creation time of the container in nanoseconds. int64 created_at = 7; // Key-value pairs that may be used to scope and select individual resources. map labels = 8; // Unstructured key-value map holding arbitrary metadata. // 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. 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 { // List of containers. repeated Container containers = 1; } message ContainerStatusRequest { // ID of the container for which to retrieve status. string container_id = 1; // Verbose indicates whether to return extra information about the container. bool verbose = 2; } // ContainerStatus represents the status of a container. message ContainerStatus { // ID of the container. string id = 1; // Metadata of the container. ContainerMetadata metadata = 2; // Status of the container. ContainerState state = 3; // Creation time of the container in nanoseconds. int64 created_at = 4; // Start time of the container in nanoseconds. Default: 0 (not specified). int64 started_at = 5; // Finish time of the container in nanoseconds. Default: 0 (not specified). int64 finished_at = 6; // Exit code of the container. Only required when finished_at != 0. Default: 0. int32 exit_code = 7; // Spec of the image. ImageSpec image = 8; // 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. string reason = 10; // Human-readable message indicating details about why container is in its // current state. string message = 11; // Key-value pairs that may be used to scope and select individual resources. map labels = 12; // Unstructured key-value map holding arbitrary metadata. // 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 the Container this status represents. map annotations = 13; // Mounts for the container. repeated Mount mounts = 14; // Log path of container. 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 { // Status of the container. ContainerStatus status = 1; // Info is extra information of the Container. The key could be arbitrary string, and // value should be in json format. The information could include anything useful for // debug, e.g. pid for linux container based container runtime. // It should only be returned non-empty when Verbose is true. map info = 2; } // ContainerResources holds resource limits configuration for a container. message ContainerResources { // Resource limits configuration specific to Linux container. LinuxContainerResources linux = 1; // Resource limits configuration specific to Windows container. 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; // Resource configuration specific to Linux containers. LinuxContainerResources linux = 2; // Resource configuration specific to Windows containers. WindowsContainerResources windows = 3; // Unstructured key-value map holding arbitrary additional information for // container resources updating. This can be used for specifying experimental // resources to update or other options to use when updating the container. map annotations = 4; } message UpdateContainerResourcesResponse {} message ExecSyncRequest { // ID of the container. string container_id = 1; // Command to execute. repeated string cmd = 2; // Timeout in seconds to stop the command. Default: 0 (run forever). int64 timeout = 3; } message ExecSyncResponse { // Captured command stdout output. // The runtime should cap the output of this response to 16MB. // If the stdout of the command produces more than 16MB, the remaining output // should be discarded, and the command should proceed with no error. // See CVE-2022-1708 and CVE-2022-31030 for more information. bytes stdout = 1; // Captured command stderr output. // The runtime should cap the output of this response to 16MB. // If the stderr of the command produces more than 16MB, the remaining output // should be discarded, and the command should proceed with no error. // See CVE-2022-1708 and CVE-2022-31030 for more information. bytes stderr = 2; // Exit code the command finished with. Default: 0 (success). int32 exit_code = 3; } message ExecRequest { // ID of the container in which to execute the command. string container_id = 1; // Command to execute. repeated string cmd = 2; // Whether to exec the command in a TTY. bool tty = 3; // Whether to stream stdin. // One of `stdin`, `stdout`, and `stderr` MUST be true. bool stdin = 4; // Whether to stream stdout. // One of `stdin`, `stdout`, and `stderr` MUST be true. bool stdout = 5; // Whether to stream stderr. // One of `stdin`, `stdout`, and `stderr` MUST be true. // If `tty` is true, `stderr` MUST be false. Multiplexing is not supported // in this case. The output of stdout and stderr will be combined to a // single stream. bool stderr = 6; } message ExecResponse { // Fully qualified URL of the exec streaming server. string url = 1; } message AttachRequest { // ID of the container to which to attach. string container_id = 1; // Whether to stream stdin. // One of `stdin`, `stdout`, and `stderr` MUST be true. bool stdin = 2; // Whether the process being attached is running in a TTY. // This must match the TTY setting in the ContainerConfig. bool tty = 3; // Whether to stream stdout. // One of `stdin`, `stdout`, and `stderr` MUST be true. bool stdout = 4; // Whether to stream stderr. // One of `stdin`, `stdout`, and `stderr` MUST be true. // If `tty` is true, `stderr` MUST be false. Multiplexing is not supported // in this case. The output of stdout and stderr will be combined to a // single stream. bool stderr = 5; } message AttachResponse { // Fully qualified URL of the attach streaming server. string url = 1; } message PortForwardRequest { // ID of the container to which to forward the port. string pod_sandbox_id = 1; // Port to forward. repeated int32 port = 2; } message PortForwardResponse { // Fully qualified URL of the port-forward streaming server. string url = 1; } message ImageFilter { // Spec of the image. ImageSpec image = 1; } message ListImagesRequest { // Filter to list images. ImageFilter filter = 1; } // Basic information about a container image. message Image { // ID of the image. string id = 1; // Other names by which this image is known. repeated string repo_tags = 2; // Digests by which this image is known. repeated string repo_digests = 3; // Size of the image in bytes. Must be > 0. uint64 size = 4; // UID that will run the command(s). This is used as a default if no user is // specified when creating the container. UID and the following user name // are mutually exclusive. Int64Value uid = 5; // User name that will run the command(s). This is used if UID is not set // and no user is specified when creating container. string username = 6; // ImageSpec for image which includes annotations ImageSpec spec = 7; // Recommendation on whether this image should be exempt from garbage collection. // It must only be treated as a recommendation -- the client can still request that the image be deleted, // and the runtime must oblige. bool pinned = 8; } message ListImagesResponse { // List of images. repeated Image images = 1; } message ImageStatusRequest { // Spec of the image. ImageSpec image = 1; // Verbose indicates whether to return extra information about the image. bool verbose = 2; } message ImageStatusResponse { // Status of the image. Image image = 1; // Info is extra information of the Image. The key could be arbitrary string, and // value should be in json format. The information could include anything useful // for debug, e.g. image config for oci image based container runtime. // It should only be returned non-empty when Verbose is true. map info = 2; } // AuthConfig contains authorization information for connecting to a registry. message AuthConfig { string username = 1; string password = 2; string auth = 3; string server_address = 4; // IdentityToken is used to authenticate the user and get // an access token for the registry. string identity_token = 5; // RegistryToken is a bearer token to be sent to a registry string registry_token = 6; } message PullImageRequest { // Spec of the image. ImageSpec image = 1; // Authentication configuration for pulling the image. AuthConfig auth = 2; // Config of the PodSandbox, which is used to pull image in PodSandbox context. PodSandboxConfig sandbox_config = 3; } message PullImageResponse { // Reference to the image in use. For most runtimes, this should be an // image ID or digest. string image_ref = 1; } message RemoveImageRequest { // Spec of the image to remove. ImageSpec image = 1; } message RemoveImageResponse {} message NetworkConfig { // CIDR to use for pod IP addresses. If the CIDR is empty, runtimes // should omit it. string pod_cidr = 1; } message RuntimeConfig { NetworkConfig network_config = 1; } message UpdateRuntimeConfigRequest { RuntimeConfig runtime_config = 1; } message UpdateRuntimeConfigResponse {} // RuntimeCondition contains condition information for the runtime. // There are 2 kinds of runtime conditions: // 1. Required conditions: Conditions are required for kubelet to work // properly. If any required condition is unmet, the node will be not ready. // The required conditions include: // * RuntimeReady: RuntimeReady means the runtime is up and ready to accept // basic containers e.g. container only needs host network. // * NetworkReady: NetworkReady means the runtime network is up and ready to // accept containers which require container network. // 2. Optional conditions: Conditions are informative to the user, but kubelet // will not rely on. Since condition type is an arbitrary string, all conditions // not required are optional. These conditions will be exposed to users to help // them understand the status of the system. message RuntimeCondition { // Type of runtime condition. string type = 1; // Status of the condition, one of true/false. Default: false. bool status = 2; // Brief CamelCase string containing reason for the condition's last transition. string reason = 3; // Human-readable message indicating details about last transition. string message = 4; } // RuntimeStatus is information about the current status of the runtime. message RuntimeStatus { // List of current observed runtime conditions. repeated RuntimeCondition conditions = 1; } message StatusRequest { // Verbose indicates whether to return extra information about the runtime. 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; // Info is extra information of the Runtime. The key could be arbitrary string, and // 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. 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 {} // UInt64Value is the wrapper of uint64. message UInt64Value { // The value. uint64 value = 1; } // FilesystemIdentifier uniquely identify the filesystem. message FilesystemIdentifier{ // Mountpoint of a filesystem. string mountpoint = 1; } // FilesystemUsage provides the filesystem usage information. message FilesystemUsage { // Timestamp in nanoseconds at which the information were collected. Must be > 0. int64 timestamp = 1; // The unique identifier of the filesystem. FilesystemIdentifier fs_id = 2; // UsedBytes represents the bytes used for images on the filesystem. // This may differ from the total bytes used on the filesystem and may not // equal CapacityBytes - AvailableBytes. UInt64Value used_bytes = 3; // InodesUsed represents the inodes used by the images. // This may not equal InodesCapacity - InodesAvailable because the underlying // filesystem may also be used for purposes other than storing images. UInt64Value inodes_used = 4; } // WindowsFilesystemUsage provides the filesystem usage information specific to Windows. message WindowsFilesystemUsage { // Timestamp in nanoseconds at which the information were collected. Must be > 0. int64 timestamp = 1; // The unique identifier of the filesystem. FilesystemIdentifier fs_id = 2; // UsedBytes represents the bytes used for images on the filesystem. // This may differ from the total bytes used on the filesystem and may not // equal CapacityBytes - AvailableBytes. UInt64Value used_bytes = 3; } 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{ // ID of the container for which to retrieve stats. string container_id = 1; } message ContainerStatsResponse { // Stats of the container. ContainerStats stats = 1; } message ListContainerStatsRequest{ // Filter for the list request. ContainerStatsFilter filter = 1; } // ContainerStatsFilter is used to filter containers. // All those fields are combined with 'AND' message ContainerStatsFilter { // ID of the container. string id = 1; // ID of the PodSandbox. string pod_sandbox_id = 2; // LabelSelector to select matches. // Only api.MatchLabels is supported for now and the requirements // are ANDed. MatchExpressions is not supported yet. map label_selector = 3; } message ListContainerStatsResponse { // Stats of the container. repeated ContainerStats stats = 1; } // ContainerAttributes provides basic information of the container. message ContainerAttributes { // ID of the container. string id = 1; // Metadata of the container. ContainerMetadata metadata = 2; // Key-value pairs that may be used to scope and select individual resources. map labels = 3; // Unstructured key-value map holding arbitrary metadata. // 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 the Container this status represents. map annotations = 4; } // ContainerStats provides the resource usage statistics for a container. message ContainerStats { // Information of the container. ContainerAttributes attributes = 1; // CPU usage gathered from the container. CpuUsage cpu = 2; // Memory usage gathered from the container. 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 message WindowsContainerStats { // Information of the container. ContainerAttributes attributes = 1; // CPU usage gathered from the container. WindowsCpuUsage cpu = 2; // Memory usage gathered from the container. WindowsMemoryUsage memory = 3; // Usage of the writable layer. WindowsFilesystemUsage writable_layer = 4; } // CpuUsage provides the CPU usage information. message CpuUsage { // Timestamp in nanoseconds at which the information were collected. Must be > 0. int64 timestamp = 1; // Cumulative CPU usage (sum across all cores) since object creation. UInt64Value usage_core_nano_seconds = 2; // Total CPU usage (sum of all cores) averaged over the sample window. // The "core" unit can be interpreted as CPU core-nanoseconds per second. UInt64Value usage_nano_cores = 3; } // WindowsCpuUsage provides the CPU usage information specific to Windows message WindowsCpuUsage { // Timestamp in nanoseconds at which the information were collected. Must be > 0. int64 timestamp = 1; // Cumulative CPU usage (sum across all cores) since object creation. UInt64Value usage_core_nano_seconds = 2; // Total CPU usage (sum of all cores) averaged over the sample window. // The "core" unit can be interpreted as CPU core-nanoseconds per second. UInt64Value usage_nano_cores = 3; } // MemoryUsage provides the memory usage information. message MemoryUsage { // 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. UInt64Value available_bytes = 3; // Total memory in use. This includes all memory regardless of when it was accessed. UInt64Value usage_bytes = 4; // The amount of anonymous and swap cache memory (includes transparent hugepages). UInt64Value rss_bytes = 5; // Cumulative number of minor page faults. UInt64Value page_faults = 6; // Cumulative number of major page faults. 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 - 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 { // ID of the container for which to reopen the log. string container_id = 1; } message ReopenContainerLogResponse{ } message CheckpointContainerRequest { // ID of the container to be checkpointed. string container_id = 1; // Location of the checkpoint archive used for export string location = 2; // Timeout in seconds for the checkpoint to complete. // Timeout of zero means to use the CRI default. // Timeout > 0 means to use the user specified timeout. int64 timeout = 3; } message CheckpointContainerResponse {} message GetEventsRequest {} message ContainerEventResponse { // ID of the container string container_id = 1; // Type of the container event ContainerEventType container_event_type = 2; // Creation timestamp in nanoseconds of this event int64 created_at = 3; // Sandbox status PodSandboxStatus pod_sandbox_status = 4; // Container statuses repeated ContainerStatus containers_statuses = 5; } enum ContainerEventType { // Container created CONTAINER_CREATED_EVENT = 0; // Container started CONTAINER_STARTED_EVENT = 1; // Container stopped CONTAINER_STOPPED_EVENT = 2; // Container deleted CONTAINER_DELETED_EVENT = 3; } message ListMetricDescriptorsRequest {} message ListMetricDescriptorsResponse { repeated MetricDescriptor descriptors = 1; } message MetricDescriptor { // The name field will be used as a unique identifier of this MetricDescriptor, // and be used in conjunction with the Metric structure to populate the full Metric. string name = 1; string help = 2; // When a metric uses this metric descriptor, it should only define // labels that have previously been declared in label_keys. // It is the responsibility of the runtime to correctly keep sorted the keys and values. // If the two slices have different length, the behavior is undefined. repeated string label_keys = 3; } message ListPodSandboxMetricsRequest {} message ListPodSandboxMetricsResponse { repeated PodSandboxMetrics pod_metrics = 1; } message PodSandboxMetrics { string pod_sandbox_id = 1; repeated Metric metrics = 2; repeated ContainerMetrics container_metrics = 3; } message ContainerMetrics { string container_id = 1; repeated Metric metrics = 2; } message Metric { // Name must match a name previously returned in a MetricDescriptors call, // otherwise, it will be ignored. string name = 1; // Timestamp should be 0 if the metric was gathered live. // If it was cached, the Timestamp should reflect the time in nanoseconds it was collected. int64 timestamp = 2; MetricType metric_type = 3; // The corresponding LabelValues to the LabelKeys defined in the MetricDescriptor. // It is the responsibility of the runtime to correctly keep sorted the keys and values. // If the two slices have different length, the behavior is undefined. repeated string label_values = 4; UInt64Value value = 5; } 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; } kubernetes-cri-api-4685890/pkg/apis/runtime/v1/constants.go000066400000000000000000000035561472465115100235240ustar00rootroot00000000000000/* Copyright 2020 The Kubernetes 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 v1 // This file contains all constants defined in CRI. // Required runtime condition type. const ( // RuntimeReady means the runtime is up and ready to accept basic containers. RuntimeReady = "RuntimeReady" // NetworkReady means the runtime network is up and ready to accept containers which require network. NetworkReady = "NetworkReady" ) // LogStreamType is the type of the stream in CRI container log. type LogStreamType string const ( // Stdout is the stream type for stdout. Stdout LogStreamType = "stdout" // Stderr is the stream type for stderr. Stderr LogStreamType = "stderr" ) // LogTag is the tag of a log line in CRI container log. // Currently defined log tags: // * First tag: Partial/Full - P/F. // The field in the container log format can be extended to include multiple // tags by using a delimiter, but changes should be rare. If it becomes clear // that better extensibility is desired, a more extensible format (e.g., json) // should be adopted as a replacement and/or addition. type LogTag string const ( // LogTagPartial means the line is part of multiple lines. LogTagPartial LogTag = "P" // LogTagFull means the line is a single full line or the end of multiple lines. LogTagFull LogTag = "F" // LogTagDelimiter is the delimiter for different log tags. LogTagDelimiter = ":" ) kubernetes-cri-api-4685890/pkg/apis/services.go000066400000000000000000000172211472465115100213140ustar00rootroot00000000000000/* Copyright 2016 The Kubernetes 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 cri import ( "context" "time" runtimeapi "k8s.io/cri-api/pkg/apis/runtime/v1" ) // RuntimeVersioner contains methods for runtime name, version and API version. type RuntimeVersioner interface { // Version returns the runtime name, runtime version and runtime API version Version(ctx context.Context, apiVersion string) (*runtimeapi.VersionResponse, error) } // ContainerManager contains methods to manipulate containers managed by a // container runtime. The methods are thread-safe. type ContainerManager interface { // CreateContainer creates a new container in specified PodSandbox. CreateContainer(ctx context.Context, podSandboxID string, config *runtimeapi.ContainerConfig, sandboxConfig *runtimeapi.PodSandboxConfig) (string, error) // StartContainer starts the container. StartContainer(ctx context.Context, containerID string) error // StopContainer stops a running container with a grace period (i.e., timeout). StopContainer(ctx context.Context, containerID string, timeout int64) error // RemoveContainer removes the container. RemoveContainer(ctx context.Context, containerID string) error // ListContainers lists all containers by filters. ListContainers(ctx context.Context, filter *runtimeapi.ContainerFilter) ([]*runtimeapi.Container, error) // ContainerStatus returns the status of the container. ContainerStatus(ctx context.Context, containerID string, verbose bool) (*runtimeapi.ContainerStatusResponse, error) // UpdateContainerResources updates ContainerConfig of the container synchronously. // If runtime fails to transactionally update the requested resources, an error is returned. UpdateContainerResources(ctx context.Context, containerID string, resources *runtimeapi.ContainerResources) error // ExecSync executes a command in the container, and returns the stdout output. // If command exits with a non-zero exit code, an error is returned. ExecSync(ctx context.Context, containerID string, cmd []string, timeout time.Duration) (stdout []byte, stderr []byte, err error) // Exec prepares a streaming endpoint to execute a command in the container, and returns the address. Exec(ctx context.Context, request *runtimeapi.ExecRequest) (*runtimeapi.ExecResponse, error) // Attach prepares a streaming endpoint to attach to a running container, and returns the address. Attach(ctx context.Context, req *runtimeapi.AttachRequest) (*runtimeapi.AttachResponse, error) // ReopenContainerLog asks runtime to reopen the stdout/stderr log file // for the container. If it returns error, new container log file MUST NOT // be created. ReopenContainerLog(ctx context.Context, ContainerID string) error // CheckpointContainer checkpoints a container CheckpointContainer(ctx context.Context, options *runtimeapi.CheckpointContainerRequest) error // GetContainerEvents gets container events from the CRI runtime GetContainerEvents(ctx context.Context, containerEventsCh chan *runtimeapi.ContainerEventResponse, connectionEstablishedCallback func(runtimeapi.RuntimeService_GetContainerEventsClient)) error } // PodSandboxManager contains methods for operating on PodSandboxes. The methods // are thread-safe. type PodSandboxManager interface { // RunPodSandbox creates and starts a pod-level sandbox. Runtimes should ensure // the sandbox is in ready state. RunPodSandbox(ctx context.Context, config *runtimeapi.PodSandboxConfig, runtimeHandler string) (string, error) // StopPodSandbox stops the sandbox. If there are any running containers in the // sandbox, they should be force terminated. StopPodSandbox(pctx context.Context, odSandboxID string) error // RemovePodSandbox removes the sandbox. If there are running containers in the // sandbox, they should be forcibly removed. RemovePodSandbox(ctx context.Context, podSandboxID string) error // PodSandboxStatus returns the Status of the PodSandbox. PodSandboxStatus(ctx context.Context, podSandboxID string, verbose bool) (*runtimeapi.PodSandboxStatusResponse, error) // ListPodSandbox returns a list of Sandbox. ListPodSandbox(ctx context.Context, filter *runtimeapi.PodSandboxFilter) ([]*runtimeapi.PodSandbox, error) // PortForward prepares a streaming endpoint to forward ports from a PodSandbox, and returns the address. PortForward(ctx context.Context, request *runtimeapi.PortForwardRequest) (*runtimeapi.PortForwardResponse, error) } // ContainerStatsManager contains methods for retrieving the container // statistics. type ContainerStatsManager interface { // ContainerStats returns stats of the container. If the container does not // exist, the call returns an error. ContainerStats(ctx context.Context, containerID string) (*runtimeapi.ContainerStats, error) // ListContainerStats returns stats of all running containers. ListContainerStats(ctx context.Context, filter *runtimeapi.ContainerStatsFilter) ([]*runtimeapi.ContainerStats, error) // PodSandboxStats returns stats of the pod. If the pod does not // exist, the call returns an error. PodSandboxStats(ctx context.Context, podSandboxID string) (*runtimeapi.PodSandboxStats, error) // ListPodSandboxStats returns stats of all running pods. ListPodSandboxStats(ctx context.Context, filter *runtimeapi.PodSandboxStatsFilter) ([]*runtimeapi.PodSandboxStats, error) // ListMetricDescriptors gets the descriptors for the metrics that will be returned in ListPodSandboxMetrics. ListMetricDescriptors(ctx context.Context) ([]*runtimeapi.MetricDescriptor, error) // ListPodSandboxMetrics returns metrics of all running pods. ListPodSandboxMetrics(ctx context.Context) ([]*runtimeapi.PodSandboxMetrics, error) } // RuntimeService interface should be implemented by a container runtime. // The methods should be thread-safe. type RuntimeService interface { RuntimeVersioner ContainerManager PodSandboxManager ContainerStatsManager // UpdateRuntimeConfig updates runtime configuration if specified UpdateRuntimeConfig(ctx context.Context, runtimeConfig *runtimeapi.RuntimeConfig) error // Status returns the status of the runtime. Status(ctx context.Context, verbose bool) (*runtimeapi.StatusResponse, error) // RuntimeConfig returns the configuration information of the runtime. RuntimeConfig(ctx context.Context) (*runtimeapi.RuntimeConfigResponse, error) } // ImageManagerService interface should be implemented by a container image // manager. // The methods should be thread-safe. type ImageManagerService interface { // ListImages lists the existing images. ListImages(ctx context.Context, filter *runtimeapi.ImageFilter) ([]*runtimeapi.Image, error) // ImageStatus returns the status of the image. ImageStatus(ctx context.Context, image *runtimeapi.ImageSpec, verbose bool) (*runtimeapi.ImageStatusResponse, error) // PullImage pulls an image with the authentication config. PullImage(ctx context.Context, image *runtimeapi.ImageSpec, auth *runtimeapi.AuthConfig, podSandboxConfig *runtimeapi.PodSandboxConfig) (string, error) // RemoveImage removes the image. RemoveImage(ctx context.Context, image *runtimeapi.ImageSpec) error // ImageFsInfo returns information of the filesystem(s) used to store the read-only layers and the writeable layer. ImageFsInfo(ctx context.Context) (*runtimeapi.ImageFsInfoResponse, error) } kubernetes-cri-api-4685890/pkg/apis/testing/000077500000000000000000000000001472465115100206145ustar00rootroot00000000000000kubernetes-cri-api-4685890/pkg/apis/testing/fake_image_service.go000066400000000000000000000156151472465115100247430ustar00rootroot00000000000000/* Copyright 2016 The Kubernetes 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 testing import ( "context" "sync" "testing" "github.com/stretchr/testify/assert" runtimeapi "k8s.io/cri-api/pkg/apis/runtime/v1" ) // FakeImageService fakes the image service. type FakeImageService struct { sync.Mutex FakeImageSize uint64 Called []string Errors map[string][]error Images map[string]*runtimeapi.Image Pinned map[string]bool pulledImages []*pulledImage FakeFilesystemUsage []*runtimeapi.FilesystemUsage FakeContainerFilesystemUsage []*runtimeapi.FilesystemUsage } // SetFakeImages sets the list of fake images for the FakeImageService. func (r *FakeImageService) SetFakeImages(images []string) { r.Lock() defer r.Unlock() r.Images = make(map[string]*runtimeapi.Image) for _, image := range images { r.Images[image] = r.makeFakeImage( &runtimeapi.ImageSpec{ Image: image, Annotations: make(map[string]string)}) } } // SetFakeImagesWithAnnotations sets the list of fake images for the FakeImageService with annotations. func (r *FakeImageService) SetFakeImagesWithAnnotations(imageSpecs []*runtimeapi.ImageSpec) { r.Lock() defer r.Unlock() r.Images = make(map[string]*runtimeapi.Image) for _, imageSpec := range imageSpecs { r.Images[imageSpec.Image] = r.makeFakeImage(imageSpec) } } // SetFakeImageSize sets the image size for the FakeImageService. func (r *FakeImageService) SetFakeImageSize(size uint64) { r.Lock() defer r.Unlock() r.FakeImageSize = size } // SetFakeImagePinned sets the image Pinned field for one image. func (r *FakeImageService) SetFakeImagePinned(image string, pinned bool) { r.Lock() defer r.Unlock() if r.Pinned == nil { r.Pinned = make(map[string]bool) } r.Pinned[image] = pinned } // SetFakeFilesystemUsage sets the FilesystemUsage for FakeImageService. func (r *FakeImageService) SetFakeFilesystemUsage(usage []*runtimeapi.FilesystemUsage) { r.Lock() defer r.Unlock() r.FakeFilesystemUsage = usage } // SetFakeFilesystemUsage sets the FilesystemUsage for FakeImageService. func (r *FakeImageService) SetFakeContainerFilesystemUsage(usage []*runtimeapi.FilesystemUsage) { r.Lock() defer r.Unlock() r.FakeContainerFilesystemUsage = usage } // NewFakeImageService creates a new FakeImageService. func NewFakeImageService() *FakeImageService { return &FakeImageService{ Called: make([]string, 0), Errors: make(map[string][]error), Images: make(map[string]*runtimeapi.Image), } } func (r *FakeImageService) makeFakeImage(image *runtimeapi.ImageSpec) *runtimeapi.Image { return &runtimeapi.Image{ Id: image.Image, Size_: r.FakeImageSize, Spec: image, RepoTags: []string{image.Image}, Pinned: r.Pinned[image.Image], } } // stringInSlice returns true if s is in list func stringInSlice(s string, list []string) bool { for _, v := range list { if v == s { return true } } return false } // InjectError sets the error message for the FakeImageService. func (r *FakeImageService) InjectError(f string, err error) { r.Lock() defer r.Unlock() r.Errors[f] = append(r.Errors[f], err) } // caller of popError must grab a lock. func (r *FakeImageService) popError(f string) error { if r.Errors == nil { return nil } errs := r.Errors[f] if len(errs) == 0 { return nil } err, errs := errs[0], errs[1:] r.Errors[f] = errs return err } // ListImages returns the list of images from FakeImageService or error if it was previously set. func (r *FakeImageService) ListImages(_ context.Context, filter *runtimeapi.ImageFilter) ([]*runtimeapi.Image, error) { r.Lock() defer r.Unlock() r.Called = append(r.Called, "ListImages") if err := r.popError("ListImages"); err != nil { return nil, err } images := make([]*runtimeapi.Image, 0) for _, img := range r.Images { if filter != nil && filter.Image != nil { if !stringInSlice(filter.Image.Image, img.RepoTags) { continue } } images = append(images, img) } return images, nil } // ImageStatus returns the status of the image from the FakeImageService. func (r *FakeImageService) ImageStatus(_ context.Context, image *runtimeapi.ImageSpec, verbose bool) (*runtimeapi.ImageStatusResponse, error) { r.Lock() defer r.Unlock() r.Called = append(r.Called, "ImageStatus") if err := r.popError("ImageStatus"); err != nil { return nil, err } return &runtimeapi.ImageStatusResponse{Image: r.Images[image.Image]}, nil } // PullImage emulate pulling the image from the FakeImageService. func (r *FakeImageService) PullImage(_ context.Context, image *runtimeapi.ImageSpec, auth *runtimeapi.AuthConfig, podSandboxConfig *runtimeapi.PodSandboxConfig) (string, error) { r.Lock() defer r.Unlock() r.Called = append(r.Called, "PullImage") if err := r.popError("PullImage"); err != nil { return "", err } r.pulledImages = append(r.pulledImages, &pulledImage{imageSpec: image, authConfig: auth}) // ImageID should be randomized for real container runtime, but here just use // image's name for easily making fake images. imageID := image.Image if _, ok := r.Images[imageID]; !ok { r.Images[imageID] = r.makeFakeImage(image) } return imageID, nil } // RemoveImage removes image from the FakeImageService. func (r *FakeImageService) RemoveImage(_ context.Context, image *runtimeapi.ImageSpec) error { r.Lock() defer r.Unlock() r.Called = append(r.Called, "RemoveImage") if err := r.popError("RemoveImage"); err != nil { return err } // Remove the image delete(r.Images, image.Image) return nil } // ImageFsInfo returns information of the filesystem that is used to store images. func (r *FakeImageService) ImageFsInfo(_ context.Context) (*runtimeapi.ImageFsInfoResponse, error) { r.Lock() defer r.Unlock() r.Called = append(r.Called, "ImageFsInfo") if err := r.popError("ImageFsInfo"); err != nil { return nil, err } return &runtimeapi.ImageFsInfoResponse{ ImageFilesystems: r.FakeFilesystemUsage, ContainerFilesystems: r.FakeContainerFilesystemUsage, }, nil } // AssertImagePulledWithAuth validates whether the image was pulled with auth and asserts if it wasn't. func (r *FakeImageService) AssertImagePulledWithAuth(t *testing.T, image *runtimeapi.ImageSpec, auth *runtimeapi.AuthConfig, failMsg string) { r.Lock() defer r.Unlock() expected := &pulledImage{imageSpec: image, authConfig: auth} assert.Contains(t, r.pulledImages, expected, failMsg) } type pulledImage struct { imageSpec *runtimeapi.ImageSpec authConfig *runtimeapi.AuthConfig } kubernetes-cri-api-4685890/pkg/apis/testing/fake_runtime_service.go000066400000000000000000000567221472465115100253500ustar00rootroot00000000000000/* Copyright 2016 The Kubernetes 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 testing import ( "context" "fmt" "reflect" "sync" "time" runtimeapi "k8s.io/cri-api/pkg/apis/runtime/v1" ) var ( // FakeVersion is a version of a fake runtime. FakeVersion = "0.1.0" // FakeRuntimeName is the name of the fake runtime. FakeRuntimeName = "fakeRuntime" // FakePodSandboxIPs is an IP address of the fake runtime. FakePodSandboxIPs = []string{"192.168.192.168"} ) // FakePodSandbox is the fake implementation of runtimeapi.PodSandboxStatus. type FakePodSandbox struct { // PodSandboxStatus contains the runtime information for a sandbox. runtimeapi.PodSandboxStatus // RuntimeHandler is the runtime handler that was issued with the RunPodSandbox request. RuntimeHandler string } // FakeContainer is a fake container. type FakeContainer struct { // ContainerStatus contains the runtime information for a container. runtimeapi.ContainerStatus // LinuxResources contains the resources specific to linux containers. LinuxResources *runtimeapi.LinuxContainerResources // the sandbox id of this container SandboxID string } // FakeRuntimeService is a fake runetime service. type FakeRuntimeService struct { sync.Mutex Called []string Errors map[string][]error FakeStatus *runtimeapi.RuntimeStatus Containers map[string]*FakeContainer Sandboxes map[string]*FakePodSandbox FakeContainerStats map[string]*runtimeapi.ContainerStats FakePodSandboxStats map[string]*runtimeapi.PodSandboxStats FakePodSandboxMetrics map[string]*runtimeapi.PodSandboxMetrics FakeMetricDescriptors map[string]*runtimeapi.MetricDescriptor FakeContainerMetrics map[string]*runtimeapi.ContainerMetrics FakeLinuxConfiguration *runtimeapi.LinuxRuntimeConfiguration ErrorOnSandboxCreate bool } // GetContainerID returns the unique container ID from the FakeRuntimeService. func (r *FakeRuntimeService) GetContainerID(sandboxID, name string, attempt uint32) (string, error) { r.Lock() defer r.Unlock() for id, c := range r.Containers { if c.SandboxID == sandboxID && c.Metadata.Name == name && c.Metadata.Attempt == attempt { return id, nil } } return "", fmt.Errorf("container (name, attempt, sandboxID)=(%q, %d, %q) not found", name, attempt, sandboxID) } // SetFakeSandboxes sets the fake sandboxes for the FakeRuntimeService. func (r *FakeRuntimeService) SetFakeSandboxes(sandboxes []*FakePodSandbox) { r.Lock() defer r.Unlock() r.Sandboxes = make(map[string]*FakePodSandbox) for _, sandbox := range sandboxes { sandboxID := sandbox.Id r.Sandboxes[sandboxID] = sandbox } } // SetFakeContainers sets fake containers for the FakeRuntimeService. func (r *FakeRuntimeService) SetFakeContainers(containers []*FakeContainer) { r.Lock() defer r.Unlock() r.Containers = make(map[string]*FakeContainer) for _, c := range containers { containerID := c.Id r.Containers[containerID] = c } } // AssertCalls validates whether specified calls were made to the FakeRuntimeService. func (r *FakeRuntimeService) AssertCalls(calls []string) error { r.Lock() defer r.Unlock() if !reflect.DeepEqual(calls, r.Called) { return fmt.Errorf("expected %#v, got %#v", calls, r.Called) } return nil } // GetCalls returns the list of calls made to the FakeRuntimeService. func (r *FakeRuntimeService) GetCalls() []string { r.Lock() defer r.Unlock() return append([]string{}, r.Called...) } // InjectError inject the error to the next call to the FakeRuntimeService. func (r *FakeRuntimeService) InjectError(f string, err error) { r.Lock() defer r.Unlock() r.Errors[f] = append(r.Errors[f], err) } // caller of popError must grab a lock. func (r *FakeRuntimeService) popError(f string) error { if r.Errors == nil { return nil } errs := r.Errors[f] if len(errs) == 0 { return nil } err, errs := errs[0], errs[1:] r.Errors[f] = errs return err } // NewFakeRuntimeService creates a new FakeRuntimeService. func NewFakeRuntimeService() *FakeRuntimeService { return &FakeRuntimeService{ Called: make([]string, 0), Errors: make(map[string][]error), Containers: make(map[string]*FakeContainer), Sandboxes: make(map[string]*FakePodSandbox), FakeContainerStats: make(map[string]*runtimeapi.ContainerStats), FakePodSandboxStats: make(map[string]*runtimeapi.PodSandboxStats), FakePodSandboxMetrics: make(map[string]*runtimeapi.PodSandboxMetrics), FakeContainerMetrics: make(map[string]*runtimeapi.ContainerMetrics), } } // Version returns version information from the FakeRuntimeService. func (r *FakeRuntimeService) Version(_ context.Context, apiVersion string) (*runtimeapi.VersionResponse, error) { r.Lock() defer r.Unlock() r.Called = append(r.Called, "Version") if err := r.popError("Version"); err != nil { return nil, err } return &runtimeapi.VersionResponse{ Version: FakeVersion, RuntimeName: FakeRuntimeName, RuntimeVersion: FakeVersion, RuntimeApiVersion: FakeVersion, }, nil } // Status returns runtime status of the FakeRuntimeService. func (r *FakeRuntimeService) Status(_ context.Context, verbose bool) (*runtimeapi.StatusResponse, error) { r.Lock() defer r.Unlock() r.Called = append(r.Called, "Status") if err := r.popError("Status"); err != nil { return nil, err } return &runtimeapi.StatusResponse{Status: r.FakeStatus}, nil } // RunPodSandbox emulates the run of the pod sandbox in the FakeRuntimeService. func (r *FakeRuntimeService) RunPodSandbox(_ context.Context, config *runtimeapi.PodSandboxConfig, runtimeHandler string) (string, error) { r.Lock() defer r.Unlock() r.Called = append(r.Called, "RunPodSandbox") if err := r.popError("RunPodSandbox"); err != nil { return "", err } if r.ErrorOnSandboxCreate { return "", fmt.Errorf("error on sandbox create") } // PodSandboxID should be randomized for real container runtime, but here just use // fixed name from BuildSandboxName() for easily making fake sandboxes. podSandboxID := BuildSandboxName(config.Metadata) createdAt := time.Now().UnixNano() r.Sandboxes[podSandboxID] = &FakePodSandbox{ PodSandboxStatus: runtimeapi.PodSandboxStatus{ Id: podSandboxID, Metadata: config.Metadata, State: runtimeapi.PodSandboxState_SANDBOX_READY, CreatedAt: createdAt, Network: &runtimeapi.PodSandboxNetworkStatus{ Ip: FakePodSandboxIPs[0], }, // Without setting sandboxStatus's Linux.Namespaces.Options, kubeGenericRuntimeManager's podSandboxChanged will consider it as network // namespace changed and always recreate sandbox which causes pod creation failed. // Ref `sandboxStatus.GetLinux().GetNamespaces().GetOptions().GetNetwork() != networkNamespaceForPod(pod)` in podSandboxChanged function. Linux: &runtimeapi.LinuxPodSandboxStatus{ Namespaces: &runtimeapi.Namespace{ Options: config.GetLinux().GetSecurityContext().GetNamespaceOptions(), }, }, Labels: config.Labels, Annotations: config.Annotations, RuntimeHandler: runtimeHandler, }, RuntimeHandler: runtimeHandler, } // assign additional IPs additionalIPs := FakePodSandboxIPs[1:] additionalPodIPs := make([]*runtimeapi.PodIP, 0, len(additionalIPs)) for _, ip := range additionalIPs { additionalPodIPs = append(additionalPodIPs, &runtimeapi.PodIP{ Ip: ip, }) } r.Sandboxes[podSandboxID].PodSandboxStatus.Network.AdditionalIps = additionalPodIPs return podSandboxID, nil } // StopPodSandbox emulates the stop of pod sandbox in the FakeRuntimeService. func (r *FakeRuntimeService) StopPodSandbox(_ context.Context, podSandboxID string) error { r.Lock() defer r.Unlock() r.Called = append(r.Called, "StopPodSandbox") if err := r.popError("StopPodSandbox"); err != nil { return err } if s, ok := r.Sandboxes[podSandboxID]; ok { s.State = runtimeapi.PodSandboxState_SANDBOX_NOTREADY } else { return fmt.Errorf("pod sandbox %s not found", podSandboxID) } return nil } // RemovePodSandbox emulates removal of the pod sadbox in the FakeRuntimeService. func (r *FakeRuntimeService) RemovePodSandbox(_ context.Context, podSandboxID string) error { r.Lock() defer r.Unlock() r.Called = append(r.Called, "RemovePodSandbox") if err := r.popError("RemovePodSandbox"); err != nil { return err } // Remove the pod sandbox delete(r.Sandboxes, podSandboxID) return nil } // PodSandboxStatus returns pod sandbox status from the FakeRuntimeService. func (r *FakeRuntimeService) PodSandboxStatus(_ context.Context, podSandboxID string, verbose bool) (*runtimeapi.PodSandboxStatusResponse, error) { r.Lock() defer r.Unlock() r.Called = append(r.Called, "PodSandboxStatus") if err := r.popError("PodSandboxStatus"); err != nil { return nil, err } s, ok := r.Sandboxes[podSandboxID] if !ok { return nil, fmt.Errorf("pod sandbox %q not found", podSandboxID) } status := s.PodSandboxStatus return &runtimeapi.PodSandboxStatusResponse{Status: &status}, nil } // ListPodSandbox returns the list of pod sandboxes in the FakeRuntimeService. func (r *FakeRuntimeService) ListPodSandbox(_ context.Context, filter *runtimeapi.PodSandboxFilter) ([]*runtimeapi.PodSandbox, error) { r.Lock() defer r.Unlock() r.Called = append(r.Called, "ListPodSandbox") if err := r.popError("ListPodSandbox"); err != nil { return nil, err } result := make([]*runtimeapi.PodSandbox, 0) for id, s := range r.Sandboxes { if filter != nil { if filter.Id != "" && filter.Id != id { continue } if filter.State != nil && filter.GetState().State != s.State { continue } if filter.LabelSelector != nil && !filterInLabels(filter.LabelSelector, s.GetLabels()) { continue } } result = append(result, &runtimeapi.PodSandbox{ Id: s.Id, Metadata: s.Metadata, State: s.State, CreatedAt: s.CreatedAt, Labels: s.Labels, Annotations: s.Annotations, RuntimeHandler: s.RuntimeHandler, }) } return result, nil } // PortForward emulates the set up of port forward in the FakeRuntimeService. func (r *FakeRuntimeService) PortForward(context.Context, *runtimeapi.PortForwardRequest) (*runtimeapi.PortForwardResponse, error) { r.Lock() defer r.Unlock() r.Called = append(r.Called, "PortForward") if err := r.popError("PortForward"); err != nil { return nil, err } return &runtimeapi.PortForwardResponse{}, nil } // CreateContainer emulates container creation in the FakeRuntimeService. func (r *FakeRuntimeService) CreateContainer(_ context.Context, podSandboxID string, config *runtimeapi.ContainerConfig, sandboxConfig *runtimeapi.PodSandboxConfig) (string, error) { r.Lock() defer r.Unlock() r.Called = append(r.Called, "CreateContainer") if err := r.popError("CreateContainer"); err != nil { return "", err } // ContainerID should be randomized for real container runtime, but here just use // fixed BuildContainerName() for easily making fake containers. containerID := BuildContainerName(config.Metadata, podSandboxID) createdAt := time.Now().UnixNano() createdState := runtimeapi.ContainerState_CONTAINER_CREATED imageRef := config.Image.Image r.Containers[containerID] = &FakeContainer{ ContainerStatus: runtimeapi.ContainerStatus{ Id: containerID, Metadata: config.Metadata, Image: config.Image, ImageRef: imageRef, CreatedAt: createdAt, State: createdState, Labels: config.Labels, Annotations: config.Annotations, }, SandboxID: podSandboxID, LinuxResources: config.GetLinux().GetResources(), } return containerID, nil } // StartContainer emulates start of a container in the FakeRuntimeService. func (r *FakeRuntimeService) StartContainer(_ context.Context, containerID string) error { r.Lock() defer r.Unlock() r.Called = append(r.Called, "StartContainer") if err := r.popError("StartContainer"); err != nil { return err } c, ok := r.Containers[containerID] if !ok { return fmt.Errorf("container %s not found", containerID) } // Set container to running. c.State = runtimeapi.ContainerState_CONTAINER_RUNNING c.StartedAt = time.Now().UnixNano() return nil } // StopContainer emulates stop of a container in the FakeRuntimeService. func (r *FakeRuntimeService) StopContainer(_ context.Context, containerID string, timeout int64) error { r.Lock() defer r.Unlock() r.Called = append(r.Called, "StopContainer") if err := r.popError("StopContainer"); err != nil { return err } c, ok := r.Containers[containerID] if !ok { return fmt.Errorf("container %q not found", containerID) } // Set container to exited state. finishedAt := time.Now().UnixNano() exitedState := runtimeapi.ContainerState_CONTAINER_EXITED c.State = exitedState c.FinishedAt = finishedAt return nil } // RemoveContainer emulates remove of a container in the FakeRuntimeService. func (r *FakeRuntimeService) RemoveContainer(_ context.Context, containerID string) error { r.Lock() defer r.Unlock() r.Called = append(r.Called, "RemoveContainer") if err := r.popError("RemoveContainer"); err != nil { return err } // Remove the container delete(r.Containers, containerID) return nil } // ListContainers returns the list of containers in the FakeRuntimeService. func (r *FakeRuntimeService) ListContainers(_ context.Context, filter *runtimeapi.ContainerFilter) ([]*runtimeapi.Container, error) { r.Lock() defer r.Unlock() r.Called = append(r.Called, "ListContainers") if err := r.popError("ListContainers"); err != nil { return nil, err } result := make([]*runtimeapi.Container, 0) for _, s := range r.Containers { if filter != nil { if filter.Id != "" && filter.Id != s.Id { continue } if filter.PodSandboxId != "" && filter.PodSandboxId != s.SandboxID { continue } if filter.State != nil && filter.GetState().State != s.State { continue } if filter.LabelSelector != nil && !filterInLabels(filter.LabelSelector, s.GetLabels()) { continue } } result = append(result, &runtimeapi.Container{ Id: s.Id, CreatedAt: s.CreatedAt, PodSandboxId: s.SandboxID, Metadata: s.Metadata, State: s.State, Image: s.Image, ImageRef: s.ImageRef, Labels: s.Labels, Annotations: s.Annotations, }) } return result, nil } // ContainerStatus returns the container status given the container ID in FakeRuntimeService. func (r *FakeRuntimeService) ContainerStatus(_ context.Context, containerID string, verbose bool) (*runtimeapi.ContainerStatusResponse, error) { r.Lock() defer r.Unlock() r.Called = append(r.Called, "ContainerStatus") if err := r.popError("ContainerStatus"); err != nil { return nil, err } c, ok := r.Containers[containerID] if !ok { return nil, fmt.Errorf("container %q not found", containerID) } status := c.ContainerStatus return &runtimeapi.ContainerStatusResponse{Status: &status}, nil } // UpdateContainerResources returns the container resource in the FakeRuntimeService. func (r *FakeRuntimeService) UpdateContainerResources(context.Context, string, *runtimeapi.ContainerResources) error { r.Lock() defer r.Unlock() r.Called = append(r.Called, "UpdateContainerResources") return r.popError("UpdateContainerResources") } // ExecSync emulates the sync execution of a command in a container in the FakeRuntimeService. func (r *FakeRuntimeService) ExecSync(_ context.Context, containerID string, cmd []string, timeout time.Duration) (stdout []byte, stderr []byte, err error) { r.Lock() defer r.Unlock() r.Called = append(r.Called, "ExecSync") err = r.popError("ExecSync") return } // Exec emulates the execution of a command in a container in the FakeRuntimeService. func (r *FakeRuntimeService) Exec(context.Context, *runtimeapi.ExecRequest) (*runtimeapi.ExecResponse, error) { r.Lock() defer r.Unlock() r.Called = append(r.Called, "Exec") if err := r.popError("Exec"); err != nil { return nil, err } return &runtimeapi.ExecResponse{}, nil } // Attach emulates the attach request in the FakeRuntimeService. func (r *FakeRuntimeService) Attach(_ context.Context, req *runtimeapi.AttachRequest) (*runtimeapi.AttachResponse, error) { r.Lock() defer r.Unlock() r.Called = append(r.Called, "Attach") if err := r.popError("Attach"); err != nil { return nil, err } return &runtimeapi.AttachResponse{}, nil } // UpdateRuntimeConfig emulates the update of a runtime config for the FakeRuntimeService. func (r *FakeRuntimeService) UpdateRuntimeConfig(_ context.Context, runtimeCOnfig *runtimeapi.RuntimeConfig) error { r.Lock() defer r.Unlock() r.Called = append(r.Called, "UpdateRuntimeConfig") return r.popError("UpdateRuntimeConfig") } // SetFakeContainerStats sets the fake container stats in the FakeRuntimeService. func (r *FakeRuntimeService) SetFakeContainerStats(containerStats []*runtimeapi.ContainerStats) { r.Lock() defer r.Unlock() r.FakeContainerStats = make(map[string]*runtimeapi.ContainerStats) for _, s := range containerStats { r.FakeContainerStats[s.Attributes.Id] = s } } // ContainerStats returns the container stats in the FakeRuntimeService. func (r *FakeRuntimeService) ContainerStats(_ context.Context, containerID string) (*runtimeapi.ContainerStats, error) { r.Lock() defer r.Unlock() r.Called = append(r.Called, "ContainerStats") if err := r.popError("ContainerStats"); err != nil { return nil, err } s, found := r.FakeContainerStats[containerID] if !found { return nil, fmt.Errorf("no stats for container %q", containerID) } return s, nil } // ListContainerStats returns the list of all container stats given the filter in the FakeRuntimeService. func (r *FakeRuntimeService) ListContainerStats(_ context.Context, filter *runtimeapi.ContainerStatsFilter) ([]*runtimeapi.ContainerStats, error) { r.Lock() defer r.Unlock() r.Called = append(r.Called, "ListContainerStats") if err := r.popError("ListContainerStats"); err != nil { return nil, err } var result []*runtimeapi.ContainerStats for _, c := range r.Containers { if filter != nil { if filter.Id != "" && filter.Id != c.Id { continue } if filter.PodSandboxId != "" && filter.PodSandboxId != c.SandboxID { continue } if filter.LabelSelector != nil && !filterInLabels(filter.LabelSelector, c.GetLabels()) { continue } } s, found := r.FakeContainerStats[c.Id] if !found { continue } result = append(result, s) } return result, nil } // SetFakePodSandboxStats sets the fake pod sandbox stats in the FakeRuntimeService. func (r *FakeRuntimeService) SetFakePodSandboxStats(podStats []*runtimeapi.PodSandboxStats) { r.Lock() defer r.Unlock() r.FakePodSandboxStats = make(map[string]*runtimeapi.PodSandboxStats) for _, s := range podStats { r.FakePodSandboxStats[s.Attributes.Id] = s } } // PodSandboxStats returns the sandbox stats in the FakeRuntimeService. func (r *FakeRuntimeService) PodSandboxStats(_ context.Context, podSandboxID string) (*runtimeapi.PodSandboxStats, error) { r.Lock() defer r.Unlock() r.Called = append(r.Called, "PodSandboxStats") if err := r.popError("PodSandboxStats"); err != nil { return nil, err } s, found := r.FakePodSandboxStats[podSandboxID] if !found { return nil, fmt.Errorf("no stats for pod sandbox %q", podSandboxID) } return s, nil } // ListPodSandboxStats returns the list of all pod sandbox stats given the filter in the FakeRuntimeService. func (r *FakeRuntimeService) ListPodSandboxStats(_ context.Context, filter *runtimeapi.PodSandboxStatsFilter) ([]*runtimeapi.PodSandboxStats, error) { r.Lock() defer r.Unlock() r.Called = append(r.Called, "ListPodSandboxStats") if err := r.popError("ListPodSandboxStats"); err != nil { return nil, err } var result []*runtimeapi.PodSandboxStats for _, sb := range r.Sandboxes { if filter != nil { if filter.Id != "" && filter.Id != sb.Id { continue } if filter.LabelSelector != nil && !filterInLabels(filter.LabelSelector, sb.GetLabels()) { continue } } s, found := r.FakePodSandboxStats[sb.Id] if !found { continue } result = append(result, s) } return result, nil } // ReopenContainerLog emulates call to the reopen container log in the FakeRuntimeService. func (r *FakeRuntimeService) ReopenContainerLog(_ context.Context, containerID string) error { r.Lock() defer r.Unlock() r.Called = append(r.Called, "ReopenContainerLog") if err := r.popError("ReopenContainerLog"); err != nil { return err } return nil } // CheckpointContainer emulates call to checkpoint a container in the FakeRuntimeService. func (r *FakeRuntimeService) CheckpointContainer(_ context.Context, options *runtimeapi.CheckpointContainerRequest) error { r.Lock() defer r.Unlock() r.Called = append(r.Called, "CheckpointContainer") if err := r.popError("CheckpointContainer"); err != nil { return err } return nil } func (f *FakeRuntimeService) GetContainerEvents(ctx context.Context, containerEventsCh chan *runtimeapi.ContainerEventResponse, connectionEstablishedCallback func(runtimeapi.RuntimeService_GetContainerEventsClient)) error { return nil } // SetFakeMetricDescriptors sets the fake metrics descriptors in the FakeRuntimeService. func (r *FakeRuntimeService) SetFakeMetricDescriptors(descs []*runtimeapi.MetricDescriptor) { r.Lock() defer r.Unlock() r.FakeMetricDescriptors = make(map[string]*runtimeapi.MetricDescriptor) for _, d := range descs { r.FakeMetricDescriptors[d.Name] = d } } // ListMetricDescriptors gets the descriptors for the metrics that will be returned in ListPodSandboxMetrics. func (r *FakeRuntimeService) ListMetricDescriptors(_ context.Context) ([]*runtimeapi.MetricDescriptor, error) { r.Lock() defer r.Unlock() r.Called = append(r.Called, "ListMetricDescriptors") if err := r.popError("ListMetricDescriptors"); err != nil { return nil, err } descs := make([]*runtimeapi.MetricDescriptor, 0, len(r.FakeMetricDescriptors)) for _, d := range r.FakeMetricDescriptors { descs = append(descs, d) } return descs, nil } // SetFakePodSandboxMetrics sets the fake pod sandbox metrics in the FakeRuntimeService. func (r *FakeRuntimeService) SetFakePodSandboxMetrics(podStats []*runtimeapi.PodSandboxMetrics) { r.Lock() defer r.Unlock() r.FakePodSandboxMetrics = make(map[string]*runtimeapi.PodSandboxMetrics) for _, s := range podStats { r.FakePodSandboxMetrics[s.PodSandboxId] = s } } // ListPodSandboxMetrics returns the list of all pod sandbox metrics in the FakeRuntimeService. func (r *FakeRuntimeService) ListPodSandboxMetrics(_ context.Context) ([]*runtimeapi.PodSandboxMetrics, error) { r.Lock() defer r.Unlock() r.Called = append(r.Called, "ListPodSandboxMetrics") if err := r.popError("ListPodSandboxMetrics"); err != nil { return nil, err } var result []*runtimeapi.PodSandboxMetrics for _, sb := range r.Sandboxes { s, found := r.FakePodSandboxMetrics[sb.Id] if !found { continue } result = append(result, s) } return result, nil } // RuntimeConfig returns runtime configuration of the FakeRuntimeService. func (r *FakeRuntimeService) RuntimeConfig(_ context.Context) (*runtimeapi.RuntimeConfigResponse, error) { r.Lock() defer r.Unlock() r.Called = append(r.Called, "RuntimeConfig") if err := r.popError("RuntimeConfig"); err != nil { return nil, err } return &runtimeapi.RuntimeConfigResponse{Linux: r.FakeLinuxConfiguration}, nil } kubernetes-cri-api-4685890/pkg/apis/testing/utils.go000066400000000000000000000025661472465115100223140ustar00rootroot00000000000000/* Copyright 2016 The Kubernetes 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 testing import ( "fmt" runtimeapi "k8s.io/cri-api/pkg/apis/runtime/v1" ) // BuildContainerName creates a unique container name string. func BuildContainerName(metadata *runtimeapi.ContainerMetadata, sandboxID string) string { // include the sandbox ID to make the container ID unique. return fmt.Sprintf("%s_%s_%d", sandboxID, metadata.Name, metadata.Attempt) } // BuildSandboxName creates a unique sandbox name string. func BuildSandboxName(metadata *runtimeapi.PodSandboxMetadata) string { return fmt.Sprintf("%s_%s_%s_%d", metadata.Name, metadata.Namespace, metadata.Uid, metadata.Attempt) } func filterInLabels(filter, labels map[string]string) bool { for k, v := range filter { if value, ok := labels[k]; ok { if value != v { return false } } else { return false } } return true } kubernetes-cri-api-4685890/pkg/errors/000077500000000000000000000000001472465115100175175ustar00rootroot00000000000000kubernetes-cri-api-4685890/pkg/errors/doc.go000066400000000000000000000013171472465115100206150ustar00rootroot00000000000000/* Copyright 2020 The Kubernetes 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 errors provides helper functions for use by the kubelet // to deal with CRI errors. package errors // import "k8s.io/cri-api/pkg/errors" kubernetes-cri-api-4685890/pkg/errors/errors.go000066400000000000000000000026621472465115100213700ustar00rootroot00000000000000/* Copyright 2020 The Kubernetes 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 errors import ( "errors" "google.golang.org/grpc/codes" "google.golang.org/grpc/status" ) var ( // ErrRegistryUnavailable - Get http error on the PullImage RPC call. ErrRegistryUnavailable = errors.New("RegistryUnavailable") // ErrSignatureValidationFailed - Unable to validate the image signature on the PullImage RPC call. ErrSignatureValidationFailed = errors.New("SignatureValidationFailed") // ErrRROUnsupported - Unable to enforce recursive readonly mounts ErrRROUnsupported = errors.New("RROUnsupported") ) // IsNotFound returns a boolean indicating whether the error // is grpc not found error. // See https://github.com/grpc/grpc/blob/master/doc/statuscodes.md // for a list of grpc status codes. func IsNotFound(err error) bool { s, ok := status.FromError(err) if !ok { return ok } if s.Code() == codes.NotFound { return true } return false } kubernetes-cri-api-4685890/pkg/errors/errors_test.go000066400000000000000000000023571472465115100224300ustar00rootroot00000000000000/* Copyright 2020 The Kubernetes 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 errors import ( "fmt" "testing" "google.golang.org/grpc/codes" "google.golang.org/grpc/status" ) func TestErrorIsNotFound(t *testing.T) { enf := status.Errorf(codes.NotFound, "container not found") if !IsNotFound(enf) { t.Errorf("%v expected to pass not found check", enf) } } func TestSimpleErrorDoesNotTriggerNotFound(t *testing.T) { err := fmt.Errorf("Some random error") if IsNotFound(err) { t.Errorf("%v unexpectedly passed not found check", err) } } func TestOtherGrpcErrorDoesNotTriggerNotFound(t *testing.T) { gerr := status.Errorf(codes.DeadlineExceeded, "timed out") if IsNotFound(gerr) { t.Errorf("%v unexpectedly passed not found check", gerr) } }